@polyvharmony/live-scenes-sdk 1.3.1 → 1.3.2

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(f99, g99) {
-        this.repo = f99;
-        this.useCases = g99;
+    constructor(y99, z99) {
+        this.repo = y99;
+        this.useCases = z99;
     }
     async 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.`);
+        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(d99) {
-        await this.useCases.handleStateUseCase.startStream(d99);
+    async startStream(w99) {
+        await this.useCases.handleStateUseCase.startStream(w99);
     }
     finishStream() {
         this.useCases.handleStateUseCase.finishStream();
     }
-    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;
+    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, b99.error.message);
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.UPDATE_CHANNEL_NAME_FAIL, u99.error.message);
         }
     }
-    setBitRate(z98) {
-        this.repo.mediator.linkmicMediator.setBitRate?.(z98);
+    setBitRate(s99) {
+        this.repo.mediator.linkmicMediator.setBitRate?.(s99);
     }
-    setPushResolutionRatio(y98) {
-        this.repo.mediator.linkmicMediator.setPushResolutionRatio?.(y98);
+    setPushResolutionRatio(r99) {
+        this.repo.mediator.linkmicMediator.setPushResolutionRatio?.(r99);
     }
-    setPushOrientation(x98) {
-        this.repo.mediator.linkmicMediator.setPushOrientation?.(x98);
+    setPushOrientation(q99) {
+        this.repo.mediator.linkmicMediator.setPushOrientation?.(q99);
     }
-    setPushDowngradePreference(w98) {
-        this.repo.mediator.linkmicMediator.setPushDowngradePreference?.(w98);
+    setPushDowngradePreference(p99) {
+        this.repo.mediator.linkmicMediator.setPushDowngradePreference?.(p99);
     }
-    setMixLayoutType(v98) {
-        this.useCases.mixStreamUseCase.setMixLayoutType(v98);
+    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(h99: StreamerHandleStateUseCase, i99: 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(h99, i99) {
-        this.handleStateUseCase = h99;
-        this.mixStreamUseCase = i99;
+    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(u101: PLVStreamerRepo, v101: StreamerMixStreamUseCase);
+    constructor(n102: PLVStreamerRepo, o102: StreamerMixStreamUseCase);
     init(): void;
-    startStream(s101: 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(u101, v101) {
+    constructor(n102, o102) {
         this.impl = undefined;
-        this.repo = u101;
-        this.mixStreamUseCase = v101;
+        this.repo = n102;
+        this.mixStreamUseCase = o102;
     }
     init() {
-        const t101 = this.repo.mediator.channelData?.viewerType;
-        if (t101 === 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 (t101 === PLVUserType.USERTYPE_GUEST) {
+        else if (m102 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new StreamerGuestHandleStateUseCase(this.repo, this.mixStreamUseCase);
         }
         else {
         }
         this.impl?.init();
     }
-    async startStream(s101) {
-        return this.impl?.startStream(s101);
+    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(y101: PLVStreamerRepo);
+    constructor(r102: PLVStreamerRepo);
     init(): void;
     startMix(): void;
     stopMix(): void;
-    setMixLayoutType(w101: 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(y101) {
+    constructor(r102) {
         this.impl = undefined;
-        this.repo = y101;
+        this.repo = r102;
     }
     init() {
-        const x101 = this.repo.mediator.channelData?.viewerType;
-        if (x101 === PLVUserType.USERTYPE_TEACHER) {
+        const q102 = this.repo.mediator.channelData?.viewerType;
+        if (q102 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new StreamerTeacherMixStreamUseCase(this.repo);
         }
-        else if (x101 === 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(w101) {
-        this.impl?.setMixLayoutType(w101);
+    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(h100: PLVStreamerRepo, i100: StreamerMixStreamUseCase);
+    constructor(a101: PLVStreamerRepo, b101: StreamerMixStreamUseCase);
     init(): void;
-    startStream(e100: 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(h100, i100) {
+    constructor(a101, b101) {
         this.updateLiveStreamStatusIntervalTask = null;
         this.disposables = [];
-        this.repo = h100;
-        this.mixStreamUseCase = i100;
+        this.repo = a101;
+        this.mixStreamUseCase = b101;
     }
     init() {
-        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (f100, g100) => this.onSocketMessage(f100, g100)));
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (y100, z100) => this.onSocketMessage(y100, z100)));
     }
-    async startStream(e100) {
+    async startStream(x100) {
         this.repo.mediator.linkmicMediator.onStreamerStart?.();
         this.startUpdateLiveStreamStatusIntervalTask();
     }
@@ -21,29 +21,29 @@ export class StreamerGuestHandleStateUseCase {
         this.stopUpdateLiveStreamStatusIntervalTask();
         this.repo.mediator.linkmicMediator.onStreamerStop?.();
     }
-    onSocketMessage(c100, d100) {
-        switch (d100) {
+    onSocketMessage(v100, w100) {
+        switch (w100) {
             case PLVSocketMessageEvent.ON_SLICE_START:
-                return this.onSocketOnSliceStart(c100);
+                return this.onSocketOnSliceStart(v100);
             case PLVSocketMessageEvent.ON_SLICE_ID:
-                return this.onSocketOnSliceID(c100);
+                return this.onSocketOnSliceID(v100);
             case PLVSocketMessageEvent.FINISH_CLASS:
-                return this.onSocketFinishClass(c100);
+                return this.onSocketFinishClass(v100);
             default:
         }
     }
-    onSocketOnSliceStart(z99) {
-        const a100 = decodeFromJson(z99, PLVStreamerSocketOnSliceStartRecv);
-        const b100 = a100.pushtime ?? Date.now();
-        this.repo.mediator.liveStartTimestamp.setValue(b100);
+    onSocketOnSliceStart(s100) {
+        const t100 = decodeFromJson(s100, PLVStreamerSocketOnSliceStartRecv);
+        const u100 = t100.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(u100);
         this.onChangeLiveStreamStatus(PLVStreamerState.START);
     }
-    onSocketOnSliceID(w99) {
-        const x99 = decodeFromJson(w99, PLVStreamerSocketOnSliceIDRecv);
-        const y99 = x99.data?.pushtime ?? Date.now();
-        this.repo.mediator.liveStartTimestamp.setValue(y99);
+    onSocketOnSliceID(p100) {
+        const q100 = decodeFromJson(p100, PLVStreamerSocketOnSliceIDRecv);
+        const r100 = q100.data?.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(r100);
     }
-    onSocketFinishClass(v99) {
+    onSocketFinishClass(o100) {
         this.onChangeLiveStreamStatus(PLVStreamerState.NOT_START);
     }
     startUpdateLiveStreamStatusIntervalTask() {
@@ -54,16 +54,16 @@ export class StreamerGuestHandleStateUseCase {
         this.updateLiveStreamStatusIntervalTask.start();
     }
     async updateLiveStreamStatus() {
-        const s99 = this.repo.mediator.channelData?.streamerData?.currentStream;
-        if (isNullOrUndefined(s99)) {
+        const l100 = this.repo.mediator.channelData?.streamerData?.currentStream;
+        if (isNullOrUndefined(l100)) {
             return;
         }
-        const t99 = await runCatching(this.repo.getLiveStatusSessionId(s99));
-        if (t99.success === false) {
+        const m100 = await runCatching(this.repo.getLiveStatusSessionId(l100));
+        if (m100.success === false) {
             return;
         }
-        const u99 = t99.data.status === "live";
-        this.onChangeLiveStreamStatus(u99 ? PLVStreamerState.START : PLVStreamerState.NOT_START);
+        const n100 = m100.data.status === "live";
+        this.onChangeLiveStreamStatus(n100 ? PLVStreamerState.START : PLVStreamerState.NOT_START);
     }
     stopUpdateLiveStreamStatusIntervalTask() {
         this.updateLiveStreamStatusIntervalTask?.cancel();
@@ -71,19 +71,19 @@ export class StreamerGuestHandleStateUseCase {
     }
     onDestroy() {
         this.stopUpdateLiveStreamStatusIntervalTask();
-        this.disposables.forEach((r99) => {
-            r99.dispose();
+        this.disposables.forEach((k100) => {
+            k100.dispose();
         });
         this.disposables = [];
     }
-    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);
+    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 (p99 !== q99) {
-            if (q99) {
+        if (i100 !== j100) {
+            if (j100) {
                 this.repo.mediator.linkmicMediator.onLiveStreamStart?.();
             }
             else {
@@ -91,22 +91,22 @@ export class StreamerGuestHandleStateUseCase {
             }
         }
     }
-    observeSocketEvent(l99, m99) {
-        const n99 = requireNotNull(this.repo.mediator.socketMediator);
-        n99.onData(l99, m99);
-        return disposable(() => n99.offData(l99, m99));
+    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(k99) {
+    constructor(d100) {
         super();
-        this.onDispose = k99;
+        this.onDispose = d100;
     }
     dispose() {
         super.dispose();
         this.onDispose?.();
     }
 }
-function disposable(j99) {
-    return new SocketDisposable(j99);
+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(k100: PLVStreamerRepo);
+    constructor(d101: PLVStreamerRepo);
     init(): void;
     startMix(): void;
     stopMix(): void;
-    setMixLayoutType(j100: 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(k100) {
-        this.repo = k100;
+    constructor(d101) {
+        this.repo = d101;
     }
     init() {
     }
@@ -8,6 +8,6 @@ export class StreamerGuestMixStreamUseCase {
     }
     stopMix() {
     }
-    setMixLayoutType(j100) {
+    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(x100: PLVStreamerRepo, y100: StreamerMixStreamUseCase);
+    constructor(q101: PLVStreamerRepo, r101: StreamerMixStreamUseCase);
     init(): void;
-    startStream(p100: 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(x100, y100) {
-        this.repo = x100;
-        this.mixStreamUseCase = y100;
+    constructor(q101, r101) {
+        this.repo = q101;
+        this.mixStreamUseCase = r101;
     }
     init() {
     }
-    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;
+    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 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);
+        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 w100 = await runCatching(this.repo.getStreamerSessionId(q100));
-        if (w100.success === false) {
-            this.repo.mediator.reportError(PLVStreamerErrorEvent.GET_SESSION_ID_FAIL, w100.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 = w100.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 o100 = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
-        runCatching(this.repo.notifyStreamEnd(o100));
+        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 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));
+        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 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));
+        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(r101: 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(m101: PLVStreamerMixLayoutType): void;
+    setMixLayoutType(f102: PLVStreamerMixLayoutType): void;
     private readMixEncodeParam;
     private readMixLayoutType;
     private readMixUserList;