@polyvharmony/live-scenes-sdk 1.3.0-rc.3 → 1.3.1

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

@@ -4,50 +4,50 @@ import { PLVUserType } from '../../socket/model/PLVUserType';
 import { PLVStreamerErrorEvent } from '../model/vo/PLVStreamerErrorEvent';
 const TAG = 'PLVStreamerManager';
 export class PLVStreamerViewModel {
-    constructor(l156, m156) {
-        this.repo = l156;
-        this.useCases = m156;
+    constructor(f99, g99) {
+        this.repo = f99;
+        this.useCases = g99;
     }
     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.`);
+        const e99 = this.repo.mediator.channelData?.viewerType;
+        if (e99 === undefined || ![PLVUserType.USERTYPE_TEACHER, PLVUserType.USERTYPE_GUEST].includes(e99)) {
+            PLVLogger.info(TAG, `viewerType ${e99} not match StreamerManager, stop init.`);
             return;
         }
         await this.repo.init();
         this.useCases.init();
     }
-    async startStream(recover) {
-        await this.useCases.handleStateUseCase.startStream(recover);
+    async startStream(d99) {
+        await this.useCases.handleStateUseCase.startStream(d99);
     }
     finishStream() {
         this.useCases.handleStateUseCase.finishStream();
     }
-    async updateChannelName(name) {
-        const response = await runCatching(this.repo.updateChannelName(name));
-        if (response.success === true) {
-            const k156 = this.repo.mediator.channelData?.streamerData;
-            if (k156 !== undefined) {
-                k156.channelName = name;
+    async updateChannelName(a99) {
+        const b99 = await runCatching(this.repo.updateChannelName(a99));
+        if (b99.success === true) {
+            const c99 = this.repo.mediator.channelData?.streamerData;
+            if (c99 !== undefined) {
+                c99.channelName = a99;
             }
         }
         else {
-            this.repo.mediator.reportError(PLVStreamerErrorEvent.UPDATE_CHANNEL_NAME_FAIL, response.error.message);
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.UPDATE_CHANNEL_NAME_FAIL, b99.error.message);
         }
     }
-    setBitRate(bitRate) {
-        this.repo.mediator.linkmicMediator.setBitRate?.(bitRate);
+    setBitRate(z98) {
+        this.repo.mediator.linkmicMediator.setBitRate?.(z98);
     }
-    setPushResolutionRatio(j156) {
-        this.repo.mediator.linkmicMediator.setPushResolutionRatio?.(j156);
+    setPushResolutionRatio(y98) {
+        this.repo.mediator.linkmicMediator.setPushResolutionRatio?.(y98);
     }
-    setPushOrientation(i156) {
-        this.repo.mediator.linkmicMediator.setPushOrientation?.(i156);
+    setPushOrientation(x98) {
+        this.repo.mediator.linkmicMediator.setPushOrientation?.(x98);
     }
-    setPushDowngradePreference(h156) {
-        this.repo.mediator.linkmicMediator.setPushDowngradePreference?.(h156);
+    setPushDowngradePreference(w98) {
+        this.repo.mediator.linkmicMediator.setPushDowngradePreference?.(w98);
     }
-    setMixLayoutType(g156) {
-        this.useCases.mixStreamUseCase.setMixLayoutType(g156);
+    setMixLayoutType(v98) {
+        this.useCases.mixStreamUseCase.setMixLayoutType(v98);
     }
 }

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

@@ -3,6 +3,6 @@ import { StreamerMixStreamUseCase } from './StreamerMixStreamUseCase';
 export declare class PLVStreamerUseCases {
     readonly handleStateUseCase: StreamerHandleStateUseCase;
     readonly mixStreamUseCase: StreamerMixStreamUseCase;
-    constructor(n156: StreamerHandleStateUseCase, o156: StreamerMixStreamUseCase);
+    constructor(h99: StreamerHandleStateUseCase, i99: StreamerMixStreamUseCase);
     init(): void;
 }

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

@@ -1,7 +1,7 @@
 export class PLVStreamerUseCases {
-    constructor(n156, o156) {
-        this.handleStateUseCase = n156;
-        this.mixStreamUseCase = o156;
+    constructor(h99, i99) {
+        this.handleStateUseCase = h99;
+        this.mixStreamUseCase = i99;
     }
     init() {
         this.handleStateUseCase.init();

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

@@ -6,9 +6,9 @@ export declare class StreamerHandleStateUseCase implements IStreamerHandleStateU
     private readonly repo;
     private readonly mixStreamUseCase;
     private impl;
-    constructor(y157: PLVStreamerRepo, z157: StreamerMixStreamUseCase);
+    constructor(u101: PLVStreamerRepo, v101: StreamerMixStreamUseCase);
     init(): void;
-    startStream(recover: boolean): Promise<void>;
+    startStream(s101: boolean): Promise<void>;
     finishStream(): void;
     onDestroy(): void;
 }

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

@@ -2,25 +2,25 @@ import { PLVUserType } from '../../../socket/model/PLVUserType';
 import { StreamerGuestHandleStateUseCase } from './roles/guest/StreamerGuestHandleStateUseCase';
 import { StreamerTeacherHandleStateUseCase } from './roles/teacher/StreamerTeacherHandleStateUseCase';
 export class StreamerHandleStateUseCase {
-    constructor(y157, z157) {
+    constructor(u101, v101) {
         this.impl = undefined;
-        this.repo = y157;
-        this.mixStreamUseCase = z157;
+        this.repo = u101;
+        this.mixStreamUseCase = v101;
     }
     init() {
-        const x157 = this.repo.mediator.channelData?.viewerType;
-        if (x157 === PLVUserType.USERTYPE_TEACHER) {
+        const t101 = this.repo.mediator.channelData?.viewerType;
+        if (t101 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new StreamerTeacherHandleStateUseCase(this.repo, this.mixStreamUseCase);
         }
-        else if (x157 === PLVUserType.USERTYPE_GUEST) {
+        else if (t101 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new StreamerGuestHandleStateUseCase(this.repo, this.mixStreamUseCase);
         }
         else {
         }
         this.impl?.init();
     }
-    async startStream(recover) {
-        return this.impl?.startStream(recover);
+    async startStream(s101) {
+        return this.impl?.startStream(s101);
     }
     finishStream() {
         return this.impl?.finishStream();

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

@@ -4,9 +4,9 @@ import { IStreamerMixStreamUseCase } from './roles/base/IStreamerMixStreamUseCas
 export declare class StreamerMixStreamUseCase implements IStreamerMixStreamUseCase {
     private readonly repo;
     private impl;
-    constructor(c158: PLVStreamerRepo);
+    constructor(y101: PLVStreamerRepo);
     init(): void;
     startMix(): void;
     stopMix(): void;
-    setMixLayoutType(a158: PLVStreamerMixLayoutType): void;
+    setMixLayoutType(w101: PLVStreamerMixLayoutType): void;
 }

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

@@ -2,16 +2,16 @@ import { StreamerTeacherMixStreamUseCase } from './roles/teacher/StreamerTeacher
 import { PLVUserType } from '../../../socket/model/PLVUserType';
 import { StreamerGuestMixStreamUseCase } from './roles/guest/StreamerGuestMixStreamUseCase';
 export class StreamerMixStreamUseCase {
-    constructor(c158) {
+    constructor(y101) {
         this.impl = undefined;
-        this.repo = c158;
+        this.repo = y101;
     }
     init() {
-        const b158 = this.repo.mediator.channelData?.viewerType;
-        if (b158 === PLVUserType.USERTYPE_TEACHER) {
+        const x101 = this.repo.mediator.channelData?.viewerType;
+        if (x101 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new StreamerTeacherMixStreamUseCase(this.repo);
         }
-        else if (b158 === PLVUserType.USERTYPE_GUEST) {
+        else if (x101 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new StreamerGuestMixStreamUseCase(this.repo);
         }
         else {
@@ -24,7 +24,7 @@ export class StreamerMixStreamUseCase {
     stopMix() {
         this.impl?.stopMix();
     }
-    setMixLayoutType(a158) {
-        this.impl?.setMixLayoutType(a158);
+    setMixLayoutType(w101) {
+        this.impl?.setMixLayoutType(w101);
     }
 }

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

@@ -6,9 +6,9 @@ export declare class StreamerGuestHandleStateUseCase implements IStreamerHandleS
     private readonly mixStreamUseCase;
     private updateLiveStreamStatusIntervalTask;
     private disposables;
-    constructor(a157: PLVStreamerRepo, b157: StreamerMixStreamUseCase);
+    constructor(h100: PLVStreamerRepo, i100: StreamerMixStreamUseCase);
     init(): void;
-    startStream(recover: boolean): Promise<void>;
+    startStream(e100: boolean): Promise<void>;
     finishStream(): void;
     private onSocketMessage;
     private onSocketOnSliceStart;

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

@@ -4,16 +4,16 @@ import { PLVDisposable, PLVScheduledTask } from '@polyvharmony/live-scenes-found
 import { decodeFromJson, isNullOrUndefined, requireNotNull, runCatching, seconds } from '@polyvharmony/media-player-sdk';
 import { PLVStreamerSocketOnSliceIDRecv, PLVStreamerSocketOnSliceStartRecv } from '../../../../model/vo/PLVStreamerSocketEvent';
 export class StreamerGuestHandleStateUseCase {
-    constructor(a157, b157) {
+    constructor(h100, i100) {
         this.updateLiveStreamStatusIntervalTask = null;
         this.disposables = [];
-        this.repo = a157;
-        this.mixStreamUseCase = b157;
+        this.repo = h100;
+        this.mixStreamUseCase = i100;
     }
     init() {
-        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (data, event) => this.onSocketMessage(data, event)));
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (f100, g100) => this.onSocketMessage(f100, g100)));
     }
-    async startStream(recover) {
+    async startStream(e100) {
         this.repo.mediator.linkmicMediator.onStreamerStart?.();
         this.startUpdateLiveStreamStatusIntervalTask();
     }
@@ -21,26 +21,29 @@ export class StreamerGuestHandleStateUseCase {
         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);
+    onSocketMessage(c100, d100) {
+        switch (d100) {
+            case PLVSocketMessageEvent.ON_SLICE_START:
+                return this.onSocketOnSliceStart(c100);
+            case PLVSocketMessageEvent.ON_SLICE_ID:
+                return this.onSocketOnSliceID(c100);
+            case PLVSocketMessageEvent.FINISH_CLASS:
+                return this.onSocketFinishClass(c100);
             default:
         }
     }
-    onSocketOnSliceStart(data) {
-        const z156 = decodeFromJson(data, PLVStreamerSocketOnSliceStartRecv);
-        const startTime = z156.pushtime ?? Date.now();
-        this.repo.mediator.liveStartTimestamp.setValue(startTime);
+    onSocketOnSliceStart(z99) {
+        const a100 = decodeFromJson(z99, PLVStreamerSocketOnSliceStartRecv);
+        const b100 = a100.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(b100);
         this.onChangeLiveStreamStatus(PLVStreamerState.START);
     }
-    onSocketOnSliceID(data) {
-        const y156 = decodeFromJson(data, PLVStreamerSocketOnSliceIDRecv);
-        const startTime = y156.data?.pushtime ?? Date.now();
-        this.repo.mediator.liveStartTimestamp.setValue(startTime);
+    onSocketOnSliceID(w99) {
+        const x99 = decodeFromJson(w99, PLVStreamerSocketOnSliceIDRecv);
+        const y99 = x99.data?.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(y99);
     }
-    onSocketFinishClass(data) {
+    onSocketFinishClass(v99) {
         this.onChangeLiveStreamStatus(PLVStreamerState.NOT_START);
     }
     startUpdateLiveStreamStatusIntervalTask() {
@@ -51,16 +54,16 @@ export class StreamerGuestHandleStateUseCase {
         this.updateLiveStreamStatusIntervalTask.start();
     }
     async updateLiveStreamStatus() {
-        const stream = this.repo.mediator.channelData?.streamerData?.currentStream;
-        if (isNullOrUndefined(stream)) {
+        const s99 = this.repo.mediator.channelData?.streamerData?.currentStream;
+        if (isNullOrUndefined(s99)) {
             return;
         }
-        const w156 = await runCatching(this.repo.getLiveStatusSessionId(stream));
-        if (w156.success === false) {
+        const t99 = await runCatching(this.repo.getLiveStatusSessionId(s99));
+        if (t99.success === false) {
             return;
         }
-        const x156 = w156.data.status === "live";
-        this.onChangeLiveStreamStatus(x156 ? PLVStreamerState.START : PLVStreamerState.NOT_START);
+        const u99 = t99.data.status === "live";
+        this.onChangeLiveStreamStatus(u99 ? PLVStreamerState.START : PLVStreamerState.NOT_START);
     }
     stopUpdateLiveStreamStatusIntervalTask() {
         this.updateLiveStreamStatusIntervalTask?.cancel();
@@ -68,19 +71,19 @@ export class StreamerGuestHandleStateUseCase {
     }
     onDestroy() {
         this.stopUpdateLiveStreamStatusIntervalTask();
-        this.disposables.forEach((v156) => {
-            v156.dispose();
+        this.disposables.forEach((r99) => {
+            r99.dispose();
         });
         this.disposables = [];
     }
-    onChangeLiveStreamStatus(s156) {
-        const t156 = this.repo.mediator.streamerState.value === PLVStreamerState.START;
-        const u156 = s156 === PLVStreamerState.START;
-        if (this.repo.mediator.streamerState.value !== s156) {
-            this.repo.mediator.streamerState.setValue(s156);
+    onChangeLiveStreamStatus(o99) {
+        const p99 = this.repo.mediator.streamerState.value === PLVStreamerState.START;
+        const q99 = o99 === PLVStreamerState.START;
+        if (this.repo.mediator.streamerState.value !== o99) {
+            this.repo.mediator.streamerState.setValue(o99);
         }
-        if (t156 !== u156) {
-            if (u156) {
+        if (p99 !== q99) {
+            if (q99) {
                 this.repo.mediator.linkmicMediator.onLiveStreamStart?.();
             }
             else {
@@ -88,22 +91,22 @@ export class StreamerGuestHandleStateUseCase {
             }
         }
     }
-    observeSocketEvent(event, callback) {
-        const r156 = requireNotNull(this.repo.mediator.socketMediator);
-        r156.onData(event, callback);
-        return disposable(() => r156.offData(event, callback));
+    observeSocketEvent(l99, m99) {
+        const n99 = requireNotNull(this.repo.mediator.socketMediator);
+        n99.onData(l99, m99);
+        return disposable(() => n99.offData(l99, m99));
     }
 }
 class SocketDisposable extends PLVDisposable {
-    constructor(q156) {
+    constructor(k99) {
         super();
-        this.onDispose = q156;
+        this.onDispose = k99;
     }
     dispose() {
         super.dispose();
         this.onDispose?.();
     }
 }
-function disposable(p156) {
-    return new SocketDisposable(p156);
+function disposable(j99) {
+    return new SocketDisposable(j99);
 }

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

@@ -3,9 +3,9 @@ import { PLVStreamerMixLayoutType } from '../../../../model/vo/PLVStreamerMixLay
 import { IStreamerMixStreamUseCase } from '../base/IStreamerMixStreamUseCase';
 export declare class StreamerGuestMixStreamUseCase implements IStreamerMixStreamUseCase {
     private readonly repo;
-    constructor(d157: PLVStreamerRepo);
+    constructor(k100: PLVStreamerRepo);
     init(): void;
     startMix(): void;
     stopMix(): void;
-    setMixLayoutType(c157: PLVStreamerMixLayoutType): void;
+    setMixLayoutType(j100: PLVStreamerMixLayoutType): void;
 }

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

@@ -1,6 +1,6 @@
 export class StreamerGuestMixStreamUseCase {
-    constructor(d157) {
-        this.repo = d157;
+    constructor(k100) {
+        this.repo = k100;
     }
     init() {
     }
@@ -8,6 +8,6 @@ export class StreamerGuestMixStreamUseCase {
     }
     stopMix() {
     }
-    setMixLayoutType(c157) {
+    setMixLayoutType(j100) {
     }
 }

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

@@ -4,9 +4,9 @@ import { StreamerMixStreamUseCase } from '../../StreamerMixStreamUseCase';
 export declare class StreamerTeacherHandleStateUseCase implements IStreamerHandleStateUseCase {
     private readonly repo;
     private readonly mixStreamUseCase;
-    constructor(i157: PLVStreamerRepo, j157: StreamerMixStreamUseCase);
+    constructor(x100: PLVStreamerRepo, y100: StreamerMixStreamUseCase);
     init(): void;
-    startStream(recover: boolean): Promise<void>;
+    startStream(p100: boolean): Promise<void>;
     finishStream(): void;
     private emitSocketOnSliceStart;
     private emitSocketFinishClass;

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

@@ -5,70 +5,70 @@ import { PLVStreamerState } from '../../../../model/vo/PLVStreamerState';
 import { PLVStreamerSocketFinishClassSend, PLVStreamerSocketOnSliceStartData, PLVStreamerSocketOnSliceStartSend } from '../../../../model/vo/PLVStreamerSocketEvent';
 import { PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
 export class StreamerTeacherHandleStateUseCase {
-    constructor(i157, j157) {
-        this.repo = i157;
-        this.mixStreamUseCase = j157;
+    constructor(x100, y100) {
+        this.repo = x100;
+        this.mixStreamUseCase = y100;
     }
     init() {
     }
-    async startStream(recover) {
-        const stream = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
-        const e157 = requireNotNull(this.repo.mediator.linkmicMediator.currentBitRateEncodeParam.value);
-        const f157 = this.repo.mediator.linkmicMediator.currentPushOrientation.value !== PLVPushOrientation.LANDSCAPE;
-        const width = f157 ? e157.videoHeight : e157.videoWidth;
-        const height = f157 ? e157.videoWidth : e157.videoHeight;
+    async startStream(p100) {
+        const q100 = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
+        const r100 = requireNotNull(this.repo.mediator.linkmicMediator.currentBitRateEncodeParam.value);
+        const s100 = this.repo.mediator.linkmicMediator.currentPushOrientation.value !== PLVPushOrientation.LANDSCAPE;
+        const t100 = s100 ? r100.videoHeight : r100.videoWidth;
+        const u100 = s100 ? r100.videoWidth : r100.videoHeight;
         this.repo.mediator.linkmicMediator.onStreamerStart?.();
-        const g157 = await runCatching(this.repo.notifyStreamStart(stream, recover, width, height));
-        if (g157.success === false) {
-            this.repo.mediator.reportError(PLVStreamerErrorEvent.STREAMER_START_FAIL, g157.error.message);
+        const v100 = await runCatching(this.repo.notifyStreamStart(q100, p100, t100, u100));
+        if (v100.success === false) {
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.STREAMER_START_FAIL, v100.error.message);
             return;
         }
         this.mixStreamUseCase.startMix();
-        const h157 = await runCatching(this.repo.getStreamerSessionId(stream));
-        if (h157.success === false) {
-            this.repo.mediator.reportError(PLVStreamerErrorEvent.GET_SESSION_ID_FAIL, h157.error.message);
+        const w100 = await runCatching(this.repo.getStreamerSessionId(q100));
+        if (w100.success === false) {
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.GET_SESSION_ID_FAIL, w100.error.message);
             return;
         }
         this.emitSocketOnSliceStart();
-        requireNotNull(this.repo.mediator.channelData).sessionId = h157.data;
+        requireNotNull(this.repo.mediator.channelData).sessionId = w100.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));
+        const o100 = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
+        runCatching(this.repo.notifyStreamEnd(o100));
         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));
+        const m100 = new PLVStreamerSocketOnSliceStartSend();
+        m100.classInterval = 0;
+        const n100 = new PLVStreamerSocketOnSliceStartData();
+        n100.autoId = 0;
+        n100.isCamClosed = 0;
+        n100.pageId = 0;
+        n100.step = 0;
+        m100.data = n100;
+        m100.docType = 1;
+        m100.emitMode = 0;
+        m100.isNoCount = 0;
+        m100.keepClass = false;
+        m100.pushtime = Date.now();
+        m100.roomId = this.repo.mediator.channelData?.loginChannelId;
+        m100.sessionId = this.repo.mediator.channelData?.sessionId;
+        m100.streamName = this.repo.mediator.channelData?.streamerData?.stream;
+        m100.timeStamp = 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(m100));
     }
     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));
+        const l100 = new PLVStreamerSocketFinishClassSend();
+        l100.channelId = this.repo.mediator.channelData?.loginChannelId;
+        l100.clearPermission = 0;
+        l100.roomId = this.repo.mediator.channelData?.loginChannelId;
+        l100.userId = this.repo.mediator.channelData?.viewerId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(l100));
     }
     onDestroy() {
     }

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

@@ -3,7 +3,7 @@ import { PLVStreamerMixLayoutType } from '../../../../model/vo/PLVStreamerMixLay
 import { IStreamerMixStreamUseCase } from '../base/IStreamerMixStreamUseCase';
 export declare class StreamerTeacherMixStreamUseCase implements IStreamerMixStreamUseCase {
     private readonly repo;
-    constructor(w157: PLVStreamerRepo);
+    constructor(r101: PLVStreamerRepo);
     private readonly mixActionDebounce;
     private readonly mixAction;
     private updateMixObserver;
@@ -11,7 +11,7 @@ export declare class StreamerTeacherMixStreamUseCase implements IStreamerMixStre
     startMix(): void;
     private observeUpdateMix;
     stopMix(): void;
-    setMixLayoutType(s157: PLVStreamerMixLayoutType): void;
+    setMixLayoutType(m101: PLVStreamerMixLayoutType): void;
     private readMixEncodeParam;
     private readMixLayoutType;
     private readMixUserList;