@polyvharmony/live-scenes-sdk 1.3.0 → 1.3.2-rc.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(y99, z99) {
+        this.repo = y99;
+        this.useCases = z99;
     }
     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 x99 = this.repo.mediator.channelData?.viewerType;
+        if (x99 === undefined || ![PLVUserType.USERTYPE_TEACHER, PLVUserType.USERTYPE_GUEST].includes(x99)) {
+            PLVLogger.info(TAG, `viewerType ${x99} not match StreamerManager, stop init.`);
             return;
         }
         await this.repo.init();
         this.useCases.init();
     }
-    async startStream(recover) {
-        await this.useCases.handleStateUseCase.startStream(recover);
+    async startStream(w99) {
+        await this.useCases.handleStateUseCase.startStream(w99);
     }
     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(t99) {
+        const u99 = await runCatching(this.repo.updateChannelName(t99));
+        if (u99.success === true) {
+            const v99 = this.repo.mediator.channelData?.streamerData;
+            if (v99 !== undefined) {
+                v99.channelName = t99;
             }
         }
         else {
-            this.repo.mediator.reportError(PLVStreamerErrorEvent.UPDATE_CHANNEL_NAME_FAIL, response.error.message);
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.UPDATE_CHANNEL_NAME_FAIL, u99.error.message);
         }
     }
-    setBitRate(bitRate) {
-        this.repo.mediator.linkmicMediator.setBitRate?.(bitRate);
+    setBitRate(s99) {
+        this.repo.mediator.linkmicMediator.setBitRate?.(s99);
     }
-    setPushResolutionRatio(j156) {
-        this.repo.mediator.linkmicMediator.setPushResolutionRatio?.(j156);
+    setPushResolutionRatio(r99) {
+        this.repo.mediator.linkmicMediator.setPushResolutionRatio?.(r99);
     }
-    setPushOrientation(i156) {
-        this.repo.mediator.linkmicMediator.setPushOrientation?.(i156);
+    setPushOrientation(q99) {
+        this.repo.mediator.linkmicMediator.setPushOrientation?.(q99);
     }
-    setPushDowngradePreference(h156) {
-        this.repo.mediator.linkmicMediator.setPushDowngradePreference?.(h156);
+    setPushDowngradePreference(p99) {
+        this.repo.mediator.linkmicMediator.setPushDowngradePreference?.(p99);
     }
-    setMixLayoutType(g156) {
-        this.useCases.mixStreamUseCase.setMixLayoutType(g156);
+    setMixLayoutType(o99) {
+        this.useCases.mixStreamUseCase.setMixLayoutType(o99);
     }
 }

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(a100: StreamerHandleStateUseCase, b100: 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(a100, b100) {
+        this.handleStateUseCase = a100;
+        this.mixStreamUseCase = b100;
     }
     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(n102: PLVStreamerRepo, o102: StreamerMixStreamUseCase);
     init(): void;
-    startStream(recover: boolean): Promise<void>;
+    startStream(l102: 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(n102, o102) {
         this.impl = undefined;
-        this.repo = y157;
-        this.mixStreamUseCase = z157;
+        this.repo = n102;
+        this.mixStreamUseCase = o102;
     }
     init() {
-        const x157 = this.repo.mediator.channelData?.viewerType;
-        if (x157 === PLVUserType.USERTYPE_TEACHER) {
+        const m102 = this.repo.mediator.channelData?.viewerType;
+        if (m102 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new StreamerTeacherHandleStateUseCase(this.repo, this.mixStreamUseCase);
         }
-        else if (x157 === PLVUserType.USERTYPE_GUEST) {
+        else if (m102 === 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(l102) {
+        return this.impl?.startStream(l102);
     }
     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(r102: PLVStreamerRepo);
     init(): void;
     startMix(): void;
     stopMix(): void;
-    setMixLayoutType(a158: PLVStreamerMixLayoutType): void;
+    setMixLayoutType(p102: 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(r102) {
         this.impl = undefined;
-        this.repo = c158;
+        this.repo = r102;
     }
     init() {
-        const b158 = this.repo.mediator.channelData?.viewerType;
-        if (b158 === PLVUserType.USERTYPE_TEACHER) {
+        const q102 = this.repo.mediator.channelData?.viewerType;
+        if (q102 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new StreamerTeacherMixStreamUseCase(this.repo);
         }
-        else if (b158 === PLVUserType.USERTYPE_GUEST) {
+        else if (q102 === 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(p102) {
+        this.impl?.setMixLayoutType(p102);
     }
 }

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(a101: PLVStreamerRepo, b101: StreamerMixStreamUseCase);
     init(): void;
-    startStream(recover: boolean): Promise<void>;
+    startStream(x100: 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(a101, b101) {
         this.updateLiveStreamStatusIntervalTask = null;
         this.disposables = [];
-        this.repo = a157;
-        this.mixStreamUseCase = b157;
+        this.repo = a101;
+        this.mixStreamUseCase = b101;
     }
     init() {
-        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (data, event) => this.onSocketMessage(data, event)));
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (y100, z100) => this.onSocketMessage(y100, z100)));
     }
-    async startStream(recover) {
+    async startStream(x100) {
         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(v100, w100) {
+        switch (w100) {
+            case PLVSocketMessageEvent.ON_SLICE_START:
+                return this.onSocketOnSliceStart(v100);
+            case PLVSocketMessageEvent.ON_SLICE_ID:
+                return this.onSocketOnSliceID(v100);
+            case PLVSocketMessageEvent.FINISH_CLASS:
+                return this.onSocketFinishClass(v100);
             default:
         }
     }
-    onSocketOnSliceStart(data) {
-        const z156 = decodeFromJson(data, PLVStreamerSocketOnSliceStartRecv);
-        const startTime = z156.pushtime ?? Date.now();
-        this.repo.mediator.liveStartTimestamp.setValue(startTime);
+    onSocketOnSliceStart(s100) {
+        const t100 = decodeFromJson(s100, PLVStreamerSocketOnSliceStartRecv);
+        const u100 = t100.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(u100);
         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(p100) {
+        const q100 = decodeFromJson(p100, PLVStreamerSocketOnSliceIDRecv);
+        const r100 = q100.data?.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(r100);
     }
-    onSocketFinishClass(data) {
+    onSocketFinishClass(o100) {
         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 l100 = this.repo.mediator.channelData?.streamerData?.currentStream;
+        if (isNullOrUndefined(l100)) {
             return;
         }
-        const w156 = await runCatching(this.repo.getLiveStatusSessionId(stream));
-        if (w156.success === false) {
+        const m100 = await runCatching(this.repo.getLiveStatusSessionId(l100));
+        if (m100.success === false) {
             return;
         }
-        const x156 = w156.data.status === "live";
-        this.onChangeLiveStreamStatus(x156 ? PLVStreamerState.START : PLVStreamerState.NOT_START);
+        const n100 = m100.data.status === "live";
+        this.onChangeLiveStreamStatus(n100 ? 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((k100) => {
+            k100.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(h100) {
+        const i100 = this.repo.mediator.streamerState.value === PLVStreamerState.START;
+        const j100 = h100 === PLVStreamerState.START;
+        if (this.repo.mediator.streamerState.value !== h100) {
+            this.repo.mediator.streamerState.setValue(h100);
         }
-        if (t156 !== u156) {
-            if (u156) {
+        if (i100 !== j100) {
+            if (j100) {
                 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(e100, f100) {
+        const g100 = requireNotNull(this.repo.mediator.socketMediator);
+        g100.onData(e100, f100);
+        return disposable(() => g100.offData(e100, f100));
     }
 }
 class SocketDisposable extends PLVDisposable {
-    constructor(q156) {
+    constructor(d100) {
         super();
-        this.onDispose = q156;
+        this.onDispose = d100;
     }
     dispose() {
         super.dispose();
         this.onDispose?.();
     }
 }
-function disposable(p156) {
-    return new SocketDisposable(p156);
+function disposable(c100) {
+    return new SocketDisposable(c100);
 }

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(d101: PLVStreamerRepo);
     init(): void;
     startMix(): void;
     stopMix(): void;
-    setMixLayoutType(c157: PLVStreamerMixLayoutType): void;
+    setMixLayoutType(c101: 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(d101) {
+        this.repo = d101;
     }
     init() {
     }
@@ -8,6 +8,6 @@ export class StreamerGuestMixStreamUseCase {
     }
     stopMix() {
     }
-    setMixLayoutType(c157) {
+    setMixLayoutType(c101) {
     }
 }

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(q101: PLVStreamerRepo, r101: StreamerMixStreamUseCase);
     init(): void;
-    startStream(recover: boolean): Promise<void>;
+    startStream(i101: 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(q101, r101) {
+        this.repo = q101;
+        this.mixStreamUseCase = r101;
     }
     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(i101) {
+        const j101 = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
+        const k101 = requireNotNull(this.repo.mediator.linkmicMediator.currentBitRateEncodeParam.value);
+        const l101 = this.repo.mediator.linkmicMediator.currentPushOrientation.value !== PLVPushOrientation.LANDSCAPE;
+        const m101 = l101 ? k101.videoHeight : k101.videoWidth;
+        const n101 = l101 ? k101.videoWidth : k101.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 o101 = await runCatching(this.repo.notifyStreamStart(j101, i101, m101, n101));
+        if (o101.success === false) {
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.STREAMER_START_FAIL, o101.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 p101 = await runCatching(this.repo.getStreamerSessionId(j101));
+        if (p101.success === false) {
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.GET_SESSION_ID_FAIL, p101.error.message);
             return;
         }
         this.emitSocketOnSliceStart();
-        requireNotNull(this.repo.mediator.channelData).sessionId = h157.data;
+        requireNotNull(this.repo.mediator.channelData).sessionId = p101.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 h101 = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
+        runCatching(this.repo.notifyStreamEnd(h101));
         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 f101 = new PLVStreamerSocketOnSliceStartSend();
+        f101.classInterval = 0;
+        const g101 = new PLVStreamerSocketOnSliceStartData();
+        g101.autoId = 0;
+        g101.isCamClosed = 0;
+        g101.pageId = 0;
+        g101.step = 0;
+        f101.data = g101;
+        f101.docType = 1;
+        f101.emitMode = 0;
+        f101.isNoCount = 0;
+        f101.keepClass = false;
+        f101.pushtime = Date.now();
+        f101.roomId = this.repo.mediator.channelData?.loginChannelId;
+        f101.sessionId = this.repo.mediator.channelData?.sessionId;
+        f101.streamName = this.repo.mediator.channelData?.streamerData?.stream;
+        f101.timeStamp = 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(f101));
     }
     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 e101 = new PLVStreamerSocketFinishClassSend();
+        e101.channelId = this.repo.mediator.channelData?.loginChannelId;
+        e101.clearPermission = 0;
+        e101.roomId = this.repo.mediator.channelData?.loginChannelId;
+        e101.userId = this.repo.mediator.channelData?.viewerId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(e101));
     }
     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(k102: 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(f102: PLVStreamerMixLayoutType): void;
     private readMixEncodeParam;
     private readMixLayoutType;
     private readMixUserList;