@polyvharmony/live-scenes-sdk 1.3.1 → 1.3.2-rc.1

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

@@ -44,14 +44,14 @@ export declare class PLVStreamerManager extends PLVBaseModule {
      * 混流布局
      */
     readonly mixLayoutType: State<PLVStreamerMixLayoutType>;
-    constructor(s98: DependScope, t98: PLVChannelData, u98: PLVSocketMediator);
+    constructor(l99: DependScope, m99: PLVChannelData, n99: PLVSocketMediator);
     private init;
     /**
      * [讲师] 开始直播
      * [嘉宾] 加入直播
      * @param recover 上一次直播未正常关闭，是否继续上一次直播
      */
-    startStream(o98?: boolean): Promise<void>;
+    startStream(h99?: boolean): Promise<void>;
     /**
      * [讲师] 停止直播
      * [嘉宾] 退出直播
@@ -60,25 +60,25 @@ export declare class PLVStreamerManager extends PLVBaseModule {
     /**
      * [讲师] 更新频道名称
      */
-    updateChannelName(n98: string): Promise<void>;
+    updateChannelName(g99: string): Promise<void>;
     /**
      * [讲师、嘉宾] 设置推流清晰度
      */
-    setBitRate(m98: PLVLinkMicBitRate): void;
+    setBitRate(f99: PLVLinkMicBitRate): void;
     /**
      * [讲师、嘉宾] 设置推流画面比例
      */
-    setPushResolutionRatio(l98: PLVLinkMicPushResolutionRatio): void;
+    setPushResolutionRatio(e99: PLVLinkMicPushResolutionRatio): void;
     /**
      * [讲师、嘉宾] 设置推流方向
      */
-    setPushOrientation(k98: PLVPushOrientation): void;
+    setPushOrientation(d99: PLVPushOrientation): void;
     /**
      * [讲师、嘉宾] 设置弱网降级偏好
      */
-    setPushDowngradePreference(j98: PLVPushDowngradePreference): void;
+    setPushDowngradePreference(c99: PLVPushDowngradePreference): void;
     /**
      * [讲师] 设置混流画面类型
      */
-    setMixLayoutType(i98: PLVStreamerMixLayoutType): void;
+    setMixLayoutType(b99: PLVStreamerMixLayoutType): void;
 }

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

@@ -4,9 +4,9 @@ import { PLVStreamerMediator } from './mediator/PLVStreamerMediator';
 import { PLVStreamerErrorEvent } from './model/vo/PLVStreamerErrorEvent';
 import { PLVStreamerViewModel } from './viewmodel/PLVStreamerViewModel';
 export class PLVStreamerManager extends PLVBaseModule {
-    constructor(s98, t98, u98) {
-        super(t98);
-        this.dependScope = s98;
+    constructor(l99, m99, n99) {
+        super(m99);
+        this.dependScope = l99;
         this.mediator = this.dependScope.get(PLVStreamerMediator);
         this.viewModel = this.dependScope.get(PLVStreamerViewModel);
         this.streamerState = this.mediator.streamerState;
@@ -17,42 +17,42 @@ export class PLVStreamerManager extends PLVBaseModule {
         this.pushResolutionRatio = this.mediator.linkmicMediator.currentPushResolutionRatio;
         this.pushDowngradePreference = this.mediator.linkmicMediator.currentPushDowngradePreference;
         this.mixLayoutType = this.mediator.mixLayoutType;
-        this.init(t98, u98);
+        this.init(m99, n99);
     }
-    async init(p98, q98) {
+    async init(i99, j99) {
         await this.channelData.initializedPromise.get();
         await this.mediator.linkmicMediator.initFinish.promise;
-        this.mediator.channelData = p98;
-        this.mediator.socketMediator = q98;
-        const r98 = await runCatching(this.viewModel.init());
-        if (r98.success === false) {
-            this.mediator.reportError(PLVStreamerErrorEvent.STREAMER_INIT_FAILED, r98.error.message);
+        this.mediator.channelData = i99;
+        this.mediator.socketMediator = j99;
+        const k99 = await runCatching(this.viewModel.init());
+        if (k99.success === false) {
+            this.mediator.reportError(PLVStreamerErrorEvent.STREAMER_INIT_FAILED, k99.error.message);
         }
         this.mediator.initFinish.resolve();
     }
-    async startStream(o98 = false) {
+    async startStream(h99 = false) {
         await this.mediator.initFinish.promise;
-        await this.viewModel.startStream(o98);
+        await this.viewModel.startStream(h99);
     }
     finishStream() {
         this.viewModel.finishStream();
     }
-    async updateChannelName(n98) {
-        return this.viewModel.updateChannelName(n98);
+    async updateChannelName(g99) {
+        return this.viewModel.updateChannelName(g99);
     }
-    setBitRate(m98) {
-        this.viewModel.setBitRate(m98);
+    setBitRate(f99) {
+        this.viewModel.setBitRate(f99);
     }
-    setPushResolutionRatio(l98) {
-        this.viewModel.setPushResolutionRatio(l98);
+    setPushResolutionRatio(e99) {
+        this.viewModel.setPushResolutionRatio(e99);
     }
-    setPushOrientation(k98) {
-        this.viewModel.setPushOrientation(k98);
+    setPushOrientation(d99) {
+        this.viewModel.setPushOrientation(d99);
     }
-    setPushDowngradePreference(j98) {
-        this.viewModel.setPushDowngradePreference(j98);
+    setPushDowngradePreference(c99) {
+        this.viewModel.setPushDowngradePreference(c99);
     }
-    setMixLayoutType(i98) {
-        this.viewModel.setMixLayoutType(i98);
+    setMixLayoutType(b99) {
+        this.viewModel.setMixLayoutType(b99);
     }
 }

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

@@ -9,11 +9,11 @@ import { PLVStreamerUseCases } from '../viewmodel/usecase/PLVStreamerUseCases';
 import { StreamerHandleStateUseCase } from '../viewmodel/usecase/StreamerHandleStateUseCase';
 import { StreamerMixStreamUseCase } from '../viewmodel/usecase/StreamerMixStreamUseCase';
 export const streamerModule = new DependModule();
-streamerModule.provide(PLVStreamerMediator, (f95) => new PLVStreamerMediator(f95.get(PLVLinkMicMediator)));
-streamerModule.provide(PLVStreamerLocalDataSource, (e95) => new PLVStreamerLocalDataSource(e95.get(PLVStreamerMediator)));
-streamerModule.provide(PLVStreamerNetworkDataSource, (d95) => new PLVStreamerNetworkDataSource(d95.get(PLVStreamerMediator)));
-streamerModule.provide(PLVStreamerRepo, (c95) => new PLVStreamerRepo(c95.get(PLVStreamerMediator), c95.get(PLVStreamerLocalDataSource), c95.get(PLVStreamerNetworkDataSource)));
-streamerModule.provide(StreamerMixStreamUseCase, (b95) => new StreamerMixStreamUseCase(b95.get(PLVStreamerRepo)));
-streamerModule.provide(StreamerHandleStateUseCase, (a95) => new StreamerHandleStateUseCase(a95.get(PLVStreamerRepo), a95.get(StreamerMixStreamUseCase)));
-streamerModule.provide(PLVStreamerUseCases, (z94) => new PLVStreamerUseCases(z94.get(StreamerHandleStateUseCase), z94.get(StreamerMixStreamUseCase)));
-streamerModule.provide(PLVStreamerViewModel, (y94) => new PLVStreamerViewModel(y94.get(PLVStreamerRepo), y94.get(PLVStreamerUseCases)));
+streamerModule.provide(PLVStreamerMediator, (y95) => new PLVStreamerMediator(y95.get(PLVLinkMicMediator)));
+streamerModule.provide(PLVStreamerLocalDataSource, (x95) => new PLVStreamerLocalDataSource(x95.get(PLVStreamerMediator)));
+streamerModule.provide(PLVStreamerNetworkDataSource, (w95) => new PLVStreamerNetworkDataSource(w95.get(PLVStreamerMediator)));
+streamerModule.provide(PLVStreamerRepo, (v95) => new PLVStreamerRepo(v95.get(PLVStreamerMediator), v95.get(PLVStreamerLocalDataSource), v95.get(PLVStreamerNetworkDataSource)));
+streamerModule.provide(StreamerMixStreamUseCase, (u95) => new StreamerMixStreamUseCase(u95.get(PLVStreamerRepo)));
+streamerModule.provide(StreamerHandleStateUseCase, (t95) => new StreamerHandleStateUseCase(t95.get(PLVStreamerRepo), t95.get(StreamerMixStreamUseCase)));
+streamerModule.provide(PLVStreamerUseCases, (s95) => new PLVStreamerUseCases(s95.get(StreamerHandleStateUseCase), s95.get(StreamerMixStreamUseCase)));
+streamerModule.provide(PLVStreamerViewModel, (r95) => new PLVStreamerViewModel(r95.get(PLVStreamerRepo), r95.get(PLVStreamerUseCases)));

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

@@ -18,7 +18,7 @@ export declare class PLVStreamerMediator implements LifecycleAwareDependComponen
     readonly liveStartTimestamp: MutableState<number>;
     readonly mixLayoutType: MutableState<PLVStreamerMixLayoutType>;
     readonly errorEvent: MutableEvent<PLVStreamerErrorEvent>;
-    constructor(i95: PLVLinkMicMediator);
-    reportError(g95: number, h95: string): void;
+    constructor(b96: PLVLinkMicMediator);
+    reportError(z95: number, a96: string): void;
     onDestroy(): void;
 }

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

@@ -5,7 +5,7 @@ import { PLVStreamerMixLayoutType } from '../model/vo/PLVStreamerMixLayoutType';
 import { PLVStreamerState } from '../model/vo/PLVStreamerState';
 const TAG = "PLVStreamerManager";
 export class PLVStreamerMediator {
-    constructor(i95) {
+    constructor(b96) {
         this.channelData = null;
         this.socketMediator = null;
         this.initFinish = Promises.withResolvers();
@@ -13,11 +13,11 @@ export class PLVStreamerMediator {
         this.liveStartTimestamp = new MutableState(undefined);
         this.mixLayoutType = new MutableState(PLVStreamerMixLayoutType.TILE);
         this.errorEvent = new MutableEvent();
-        this.linkmicMediator = i95;
+        this.linkmicMediator = b96;
     }
-    reportError(g95, h95) {
-        this.errorEvent.value = new PLVStreamerErrorEvent(g95, h95);
-        PLVLogger.error(TAG, `Streamer module error, code:${g95}, message:${h95}`, true);
+    reportError(z95, a96) {
+        this.errorEvent.value = new PLVStreamerErrorEvent(z95, a96);
+        PLVLogger.error(TAG, `Streamer module error, code:${z95}, message:${a96}`, true);
     }
     onDestroy() {
         MutableSource.disposeAll(this);

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

@@ -8,14 +8,14 @@ export declare class PLVStreamerRepo {
     readonly mediator: PLVStreamerMediator;
     readonly localDataSource: PLVStreamerLocalDataSource;
     readonly networkDataSource: PLVStreamerNetworkDataSource;
-    constructor(x97: PLVStreamerMediator, y97: PLVStreamerLocalDataSource, z97: PLVStreamerNetworkDataSource);
+    constructor(q98: PLVStreamerMediator, r98: PLVStreamerLocalDataSource, s98: PLVStreamerNetworkDataSource);
     init(): Promise<void>;
     private initMixLayoutType;
-    notifyStreamStart(p97: string, q97: boolean, r97: number, s97: number): Promise<string>;
-    notifyStreamEnd(m97: string): Promise<void>;
-    setMixLayoutType(l97: PLVStreamerMixLayoutType): Promise<void>;
-    sendMixAction(k97: PLVStreamerMixActionVO): Promise<void>;
-    getStreamerSessionId(h97: string): Promise<string>;
-    updateChannelName(e97: string): Promise<void>;
-    getLiveStatusSessionId(b97: string): Promise<PLVStreamerLiveStatusResponseVO>;
+    notifyStreamStart(i98: string, j98: boolean, k98: number, l98: number): Promise<string>;
+    notifyStreamEnd(f98: string): Promise<void>;
+    setMixLayoutType(e98: PLVStreamerMixLayoutType): Promise<void>;
+    sendMixAction(d98: PLVStreamerMixActionVO): Promise<void>;
+    getStreamerSessionId(a98: string): Promise<string>;
+    updateChannelName(x97: string): Promise<void>;
+    getLiveStatusSessionId(u97: string): Promise<PLVStreamerLiveStatusResponseVO>;
 }

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

@@ -1,58 +1,58 @@
 import { requireNotNull } from '@polyvharmony/media-player-sdk';
 import { PLVStreamerMixLayoutType } from './vo/PLVStreamerMixLayoutType';
 export class PLVStreamerRepo {
-    constructor(x97, y97, z97) {
-        this.mediator = x97;
-        this.localDataSource = y97;
-        this.networkDataSource = z97;
+    constructor(q98, r98, s98) {
+        this.mediator = q98;
+        this.localDataSource = r98;
+        this.networkDataSource = s98;
     }
     async init() {
         await this.initMixLayoutType();
     }
     async initMixLayoutType() {
-        const v97 = await this.localDataSource.getMixLayoutType();
-        if (v97 !== undefined) {
-            return this.mediator.mixLayoutType.setValue(v97);
+        const o98 = await this.localDataSource.getMixLayoutType();
+        if (o98 !== undefined) {
+            return this.mediator.mixLayoutType.setValue(o98);
         }
-        const w97 = this.mediator.channelData?.liveDetail?.mobileAlonePushMixMode;
-        if (w97 === 'flatten') {
+        const p98 = this.mediator.channelData?.liveDetail?.mobileAlonePushMixMode;
+        if (p98 === 'flatten') {
             return this.setMixLayoutType(PLVStreamerMixLayoutType.TILE);
         }
-        else if (w97 === 'lecture') {
+        else if (p98 === 'lecture') {
             return this.setMixLayoutType(PLVStreamerMixLayoutType.SPEAKER);
         }
         return this.setMixLayoutType(PLVStreamerMixLayoutType.TILE);
     }
-    async notifyStreamStart(p97, q97, r97, s97) {
-        const t97 = requireNotNull(this.mediator.channelData);
-        const u97 = requireNotNull(t97.loginChannelId);
-        return this.networkDataSource.notifyStreamStart(u97, p97, q97, r97, s97);
-    }
-    async notifyStreamEnd(m97) {
-        const n97 = requireNotNull(this.mediator.channelData);
-        const o97 = requireNotNull(n97.loginChannelId);
-        return this.networkDataSource.notifyStreamEnd(o97, m97);
-    }
-    async setMixLayoutType(l97) {
-        this.mediator.mixLayoutType.setValue(l97);
-        this.localDataSource.saveMixLayoutType(l97);
-    }
-    async sendMixAction(k97) {
-        await this.networkDataSource.sendMixAction(k97);
-    }
-    async getStreamerSessionId(h97) {
-        const i97 = requireNotNull(this.mediator.channelData);
-        const j97 = requireNotNull(i97.loginChannelId);
-        return this.networkDataSource.getStreamerSessionId(j97, h97);
-    }
-    async updateChannelName(e97) {
-        const f97 = requireNotNull(this.mediator.channelData);
-        const g97 = requireNotNull(f97.loginChannelId);
-        return this.networkDataSource.updateChannelName(g97, e97);
-    }
-    async getLiveStatusSessionId(b97) {
-        const c97 = requireNotNull(this.mediator.channelData);
-        const d97 = requireNotNull(c97.loginChannelId);
-        return this.networkDataSource.getLiveStatusSessionId(d97, b97);
+    async notifyStreamStart(i98, j98, k98, l98) {
+        const m98 = requireNotNull(this.mediator.channelData);
+        const n98 = requireNotNull(m98.loginChannelId);
+        return this.networkDataSource.notifyStreamStart(n98, i98, j98, k98, l98);
+    }
+    async notifyStreamEnd(f98) {
+        const g98 = requireNotNull(this.mediator.channelData);
+        const h98 = requireNotNull(g98.loginChannelId);
+        return this.networkDataSource.notifyStreamEnd(h98, f98);
+    }
+    async setMixLayoutType(e98) {
+        this.mediator.mixLayoutType.setValue(e98);
+        this.localDataSource.saveMixLayoutType(e98);
+    }
+    async sendMixAction(d98) {
+        await this.networkDataSource.sendMixAction(d98);
+    }
+    async getStreamerSessionId(a98) {
+        const b98 = requireNotNull(this.mediator.channelData);
+        const c98 = requireNotNull(b98.loginChannelId);
+        return this.networkDataSource.getStreamerSessionId(c98, a98);
+    }
+    async updateChannelName(x97) {
+        const y97 = requireNotNull(this.mediator.channelData);
+        const z97 = requireNotNull(y97.loginChannelId);
+        return this.networkDataSource.updateChannelName(z97, x97);
+    }
+    async getLiveStatusSessionId(u97) {
+        const v97 = requireNotNull(this.mediator.channelData);
+        const w97 = requireNotNull(v97.loginChannelId);
+        return this.networkDataSource.getLiveStatusSessionId(w97, u97);
     }
 }

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

@@ -2,7 +2,7 @@ import { PLVStreamerMediator } from "../../mediator/PLVStreamerMediator";
 import { PLVStreamerMixLayoutType } from "../vo/PLVStreamerMixLayoutType";
 export declare class PLVStreamerLocalDataSource {
     private readonly mediator;
-    constructor(p95: PLVStreamerMediator);
+    constructor(i96: PLVStreamerMediator);
     getMixLayoutType(): Promise<PLVStreamerMixLayoutType | undefined>;
-    saveMixLayoutType(j95: PLVStreamerMixLayoutType): Promise<void>;
+    saveMixLayoutType(c96: PLVStreamerMixLayoutType): Promise<void>;
 }

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

@@ -1,17 +1,17 @@
 import { PLVKVStore, requireNotNull } from "@polyvharmony/media-player-sdk";
 export class PLVStreamerLocalDataSource {
-    constructor(p95) {
-        this.mediator = p95;
+    constructor(i96) {
+        this.mediator = i96;
     }
     async getMixLayoutType() {
-        const m95 = requireNotNull(this.mediator.channelData?.loginChannelId);
-        const n95 = new PLVKVStore(`plv_streamer_channel_mix_layout_type_${m95}`, Number);
-        const o95 = await n95.get();
-        return o95?.valueOf();
+        const f96 = requireNotNull(this.mediator.channelData?.loginChannelId);
+        const g96 = new PLVKVStore(`plv_streamer_channel_mix_layout_type_${f96}`, Number);
+        const h96 = await g96.get();
+        return h96?.valueOf();
     }
-    async saveMixLayoutType(j95) {
-        const k95 = requireNotNull(this.mediator.channelData?.loginChannelId);
-        const l95 = new PLVKVStore(`plv_streamer_channel_mix_layout_type_${k95}`, Number);
-        await l95.set(j95);
+    async saveMixLayoutType(c96) {
+        const d96 = requireNotNull(this.mediator.channelData?.loginChannelId);
+        const e96 = new PLVKVStore(`plv_streamer_channel_mix_layout_type_${d96}`, Number);
+        await e96.set(c96);
     }
 }

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

@@ -3,12 +3,12 @@ import { PLVStreamerLiveStatusResponseVO } from '../vo/PLVStreamerLiveStatusResp
 import { PLVStreamerMixActionVO } from '../vo/PLVStreamerMixActionVO';
 export declare class PLVStreamerNetworkDataSource {
     private readonly mediator;
-    constructor(a97: PLVStreamerMediator);
-    notifyStreamStart(r96: string, s96: string, t96: boolean, u96: number, v96: number): Promise<string>;
-    notifyStreamEnd(k96: string, l96: string): Promise<void>;
-    sendMixAction(g96: PLVStreamerMixActionVO): Promise<void>;
-    getStreamerSessionId(a96: string, b96: string): Promise<string>;
-    updateChannelName(t95: string, u95: string): Promise<void>;
-    getLiveStatusSessionId(q95: string, r95: string): Promise<PLVStreamerLiveStatusResponseVO>;
+    constructor(t97: PLVStreamerMediator);
+    notifyStreamStart(k97: string, l97: string, m97: boolean, n97: number, o97: number): Promise<string>;
+    notifyStreamEnd(d97: string, e97: string): Promise<void>;
+    sendMixAction(z96: PLVStreamerMixActionVO): Promise<void>;
+    getStreamerSessionId(t96: string, u96: string): Promise<string>;
+    updateChannelName(m96: string, n96: string): Promise<void>;
+    getLiveStatusSessionId(j96: string, k96: string): Promise<PLVStreamerLiveStatusResponseVO>;
     private get api_polyv_net();
 }

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

@@ -4,60 +4,60 @@ import BuildProfile from '../../../../../../../BuildProfile';
 import { PLVLiveChannelSettingUpdateBasicSetting, PLVLiveChannelSettingUpdateRequestVO } from '../../../business/model/PLVLiveChannelSettingUpdateRequestVO';
 import { apiPlvNetApi } from '../../../net/PLVApiPlvNetApi';
 export class PLVStreamerNetworkDataSource {
-    constructor(a97) {
-        this.mediator = a97;
+    constructor(t97) {
+        this.mediator = t97;
     }
-    async notifyStreamStart(r96, s96, t96, u96, v96) {
-        const w96 = requireNotNull(this.mediator.channelData);
-        const x96 = requireNotNull(w96.appId);
-        const y96 = requireNotNull(w96.appSecret);
-        const z96 = await this.api_polyv_net.notifyStreamStart(r96, x96, y96, s96, t96 ? "Y" : "N", u96, v96);
-        require(z96.status === 200
-            && z96.data.code === 200
-            && z96.data.data !== undefined, () => `notifyStreamStart failed: ${PLVJSONUtils.safeStringify(z96)}`);
-        return z96.data.data;
+    async notifyStreamStart(k97, l97, m97, n97, o97) {
+        const p97 = requireNotNull(this.mediator.channelData);
+        const q97 = requireNotNull(p97.appId);
+        const r97 = requireNotNull(p97.appSecret);
+        const s97 = await this.api_polyv_net.notifyStreamStart(k97, q97, r97, l97, m97 ? "Y" : "N", n97, o97);
+        require(s97.status === 200
+            && s97.data.code === 200
+            && s97.data.data !== undefined, () => `notifyStreamStart failed: ${PLVJSONUtils.safeStringify(s97)}`);
+        return s97.data.data;
     }
-    async notifyStreamEnd(k96, l96) {
-        const m96 = requireNotNull(this.mediator.channelData);
-        const n96 = requireNotNull(m96.appId);
-        const o96 = requireNotNull(m96.appSecret);
-        const p96 = BuildProfile.HAR_VERSION;
-        const q96 = await this.api_polyv_net.notifyStreamEnd(k96, n96, o96, l96, p96);
-        require(q96.status === 200
-            && q96.data.code === 200, () => `notifyStreamEnd failed: ${PLVJSONUtils.safeStringify(q96)}`);
+    async notifyStreamEnd(d97, e97) {
+        const f97 = requireNotNull(this.mediator.channelData);
+        const g97 = requireNotNull(f97.appId);
+        const h97 = requireNotNull(f97.appSecret);
+        const i97 = BuildProfile.HAR_VERSION;
+        const j97 = await this.api_polyv_net.notifyStreamEnd(d97, g97, h97, e97, i97);
+        require(j97.status === 200
+            && j97.data.code === 200, () => `notifyStreamEnd failed: ${PLVJSONUtils.safeStringify(j97)}`);
     }
-    async sendMixAction(g96) {
-        const h96 = requireNotNull(this.mediator.channelData);
-        const i96 = requireNotNull(h96.appId);
-        const j96 = requireNotNull(h96.appSecret);
-        await this.api_polyv_net.mixAction(i96, j96, g96);
+    async sendMixAction(z96) {
+        const a97 = requireNotNull(this.mediator.channelData);
+        const b97 = requireNotNull(a97.appId);
+        const c97 = requireNotNull(a97.appSecret);
+        await this.api_polyv_net.mixAction(b97, c97, z96);
     }
-    async getStreamerSessionId(a96, b96) {
-        const c96 = requireNotNull(this.mediator.channelData);
-        const d96 = requireNotNull(c96.appId);
-        const e96 = requireNotNull(c96.appSecret);
-        const f96 = await this.api_polyv_net.getStreamerSessionId(a96, d96, e96, b96);
-        require(f96.status === 200
-            && f96.data.code === 200
-            && f96.data.data !== undefined, () => `getStreamerSessionId failed: ${PLVJSONUtils.safeStringify(f96)}`);
-        return requireNotNull(f96.data.data?.sessionId, () => "getStreamerSessionId response null sessionId");
+    async getStreamerSessionId(t96, u96) {
+        const v96 = requireNotNull(this.mediator.channelData);
+        const w96 = requireNotNull(v96.appId);
+        const x96 = requireNotNull(v96.appSecret);
+        const y96 = await this.api_polyv_net.getStreamerSessionId(t96, w96, x96, u96);
+        require(y96.status === 200
+            && y96.data.code === 200
+            && y96.data.data !== undefined, () => `getStreamerSessionId failed: ${PLVJSONUtils.safeStringify(y96)}`);
+        return requireNotNull(y96.data.data?.sessionId, () => "getStreamerSessionId response null sessionId");
     }
-    async updateChannelName(t95, u95) {
-        const v95 = requireNotNull(this.mediator.channelData);
-        const w95 = requireNotNull(v95.appId);
-        const x95 = requireNotNull(v95.appSecret);
-        const y95 = new PLVLiveChannelSettingUpdateRequestVO();
-        y95.basicSetting = new PLVLiveChannelSettingUpdateBasicSetting();
-        y95.basicSetting.name = u95;
-        const z95 = await this.api_polyv_net.updateChannelBasic(t95, w95, x95, y95);
-        require(z95.status === 200
-            && z95.data.code === 200, () => `updateChannelName failed: ${PLVJSONUtils.safeStringify(z95)}`);
+    async updateChannelName(m96, n96) {
+        const o96 = requireNotNull(this.mediator.channelData);
+        const p96 = requireNotNull(o96.appId);
+        const q96 = requireNotNull(o96.appSecret);
+        const r96 = new PLVLiveChannelSettingUpdateRequestVO();
+        r96.basicSetting = new PLVLiveChannelSettingUpdateBasicSetting();
+        r96.basicSetting.name = n96;
+        const s96 = await this.api_polyv_net.updateChannelBasic(m96, p96, q96, r96);
+        require(s96.status === 200
+            && s96.data.code === 200, () => `updateChannelName failed: ${PLVJSONUtils.safeStringify(s96)}`);
     }
-    async getLiveStatusSessionId(q95, r95) {
-        const s95 = await this.api_polyv_net.getLiveStatusSessionId(q95, r95);
-        require(s95.status === 200
-            && !isNullOrUndefined(s95.data), () => `getLiveStatusSessionId failed: ${PLVJSONUtils.safeStringify(s95)}`);
-        return s95.data;
+    async getLiveStatusSessionId(j96, k96) {
+        const l96 = await this.api_polyv_net.getLiveStatusSessionId(j96, k96);
+        require(l96.status === 200
+            && !isNullOrUndefined(l96.data), () => `getLiveStatusSessionId failed: ${PLVJSONUtils.safeStringify(l96)}`);
+        return l96.data;
     }
     get api_polyv_net() {
         return apiPlvNetApi(requireNotNull(this.mediator.channelData));

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

@@ -17,5 +17,5 @@ export declare class PLVStreamerErrorEvent {
     static readonly UPDATE_CHANNEL_NAME_FAIL = 4;
     readonly code: number;
     readonly message: string;
-    constructor(a98: number, b98: string);
+    constructor(t98: number, u98: string);
 }

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

@@ -1,7 +1,7 @@
 export class PLVStreamerErrorEvent {
-    constructor(a98, b98) {
-        this.code = a98;
-        this.message = b98;
+    constructor(t98, u98) {
+        this.code = t98;
+        this.message = u98;
     }
 }
 PLVStreamerErrorEvent.STREAMER_INIT_FAILED = 1;

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

@@ -14,27 +14,27 @@ export class MixUser {
     }
 }
 export var MixAction;
-(function (f98) {
-    f98["START"] = "start";
-    f98["UPDATE"] = "update";
-    f98["END"] = "end";
+(function (y98) {
+    y98["START"] = "start";
+    y98["UPDATE"] = "update";
+    y98["END"] = "end";
 })(MixAction || (MixAction = {}));
 export var MixStreamType;
-(function (e98) {
-    e98[e98["CAMERA"] = 0] = "CAMERA";
-    e98[e98["SCREEN"] = 1] = "SCREEN";
+(function (x98) {
+    x98[x98["CAMERA"] = 0] = "CAMERA";
+    x98[x98["SCREEN"] = 1] = "SCREEN";
 })(MixStreamType || (MixStreamType = {}));
 export var MixRenderMode;
-(function (d98) {
-    d98[d98["FILL"] = 0] = "FILL";
-    d98[d98["FIT"] = 1] = "FIT";
-    d98[d98["FIT_BLACK_BACKGROUND"] = 2] = "FIT_BLACK_BACKGROUND";
+(function (w98) {
+    w98[w98["FILL"] = 0] = "FILL";
+    w98[w98["FIT"] = 1] = "FIT";
+    w98[w98["FIT_BLACK_BACKGROUND"] = 2] = "FIT_BLACK_BACKGROUND";
 })(MixRenderMode || (MixRenderMode = {}));
 export var MixInputType;
-(function (c98) {
-    c98[c98["VIDEO_AUDIO"] = 0] = "VIDEO_AUDIO";
-    c98[c98["VIDEO_ONLY"] = 1] = "VIDEO_ONLY";
-    c98[c98["AUDIO_ONLY"] = 2] = "AUDIO_ONLY";
+(function (v98) {
+    v98[v98["VIDEO_AUDIO"] = 0] = "VIDEO_AUDIO";
+    v98[v98["VIDEO_ONLY"] = 1] = "VIDEO_ONLY";
+    v98[v98["AUDIO_ONLY"] = 2] = "AUDIO_ONLY";
 })(MixInputType || (MixInputType = {}));
 export class MixPublishCdnParam {
 }

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

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

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

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

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

@@ -7,14 +7,14 @@ import { PLVStreamerUseCases } from './usecase/PLVStreamerUseCases';
 export declare class PLVStreamerViewModel {
     private readonly repo;
     private readonly useCases;
-    constructor(f99: PLVStreamerRepo, g99: PLVStreamerUseCases);
+    constructor(y99: PLVStreamerRepo, z99: PLVStreamerUseCases);
     init(): Promise<void>;
-    startStream(d99: boolean): Promise<void>;
+    startStream(w99: boolean): Promise<void>;
     finishStream(): void;
-    updateChannelName(a99: string): Promise<void>;
-    setBitRate(z98: PLVLinkMicBitRate): void;
-    setPushResolutionRatio(y98: PLVLinkMicPushResolutionRatio): void;
-    setPushOrientation(x98: PLVPushOrientation): void;
-    setPushDowngradePreference(w98: PLVPushDowngradePreference): void;
-    setMixLayoutType(v98: PLVStreamerMixLayoutType): void;
+    updateChannelName(t99: string): Promise<void>;
+    setBitRate(s99: PLVLinkMicBitRate): void;
+    setPushResolutionRatio(r99: PLVLinkMicPushResolutionRatio): void;
+    setPushOrientation(q99: PLVPushOrientation): void;
+    setPushDowngradePreference(p99: PLVPushDowngradePreference): void;
+    setMixLayoutType(o99: PLVStreamerMixLayoutType): void;
 }