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

package/src/main/ets/modules/linkmic/mediator/PLVLinkMicRTCEventCallback.js

@@ -4,66 +4,73 @@ import { PLVNetworkStatistics } from '../../net/vo/PLVNetworkStatistics';
 import { PLVLinkMicErrorEvent } from '../model/vo/PLVLinkMicErrorEvent';
 import { PLVLinkMicRTCJoinSuccess, PLVLinkMicRTCKickOut, PLVLinkMicRTCTokenExpired } from '../model/vo/PLVLinkMicRTCEvent';
 export class PLVLinkMicRTCEventCallback extends PLVRTCEngineEventCallback {
-    constructor(x108) {
+    constructor(c26) {
         super();
-        this.mediator = x108;
+        this.mediator = c26;
     }
-    onJoinChannelSuccess(v108, w108) {
-        const event = new PLVLinkMicRTCJoinSuccess();
-        event.rtcConfig = v108;
-        event.channelId = w108;
-        this.mediator.rtcEvent.value = event;
+    onJoinChannelSuccess(z25, a26) {
+        const b26 = new PLVLinkMicRTCJoinSuccess();
+        b26.rtcConfig = z25;
+        b26.channelId = a26;
+        this.mediator.rtcEvent.value = b26;
     }
-    onRemoteUserMediaStateChanged(s108, t108) {
-        const u108 = this.mediator.findViewerByLinkMicId(t108.linkmicId);
-        if (u108) {
-            u108.isVideoEnable.setValue(t108.videoEnable);
-            u108.isAudioEnable.setValue(t108.audioEnable);
-            u108.audioVolume.setValue(t108.audioVolume);
+    onRemoteUserMediaStateChanged(w25, x25) {
+        const y25 = this.mediator.findViewerByLinkMicId(x25.linkmicId);
+        if (y25) {
+            y25.isVideoEnable.setValue(x25.videoEnable);
+            y25.isAudioEnable.setValue(x25.audioEnable);
+            y25.audioVolume.setValue(x25.audioVolume);
         }
     }
-    onTokenExpired(q108, r108) {
-        const event = new PLVLinkMicRTCTokenExpired();
-        event.rtcConfig = r108;
-        event.channelId = q108;
-        this.mediator.rtcEvent.value = event;
+    onTokenExpired(t25, u25) {
+        const v25 = new PLVLinkMicRTCTokenExpired();
+        v25.rtcConfig = u25;
+        v25.channelId = t25;
+        this.mediator.rtcEvent.value = v25;
     }
-    onNetworkQuality(m108, n108, o108) {
-        if (m108 !== this.mediator.linkmicId) {
+    onNetworkQuality(p25, q25, r25) {
+        if (p25 !== this.mediator.linkmicId) {
             return;
         }
-        let p108 = this.convertNetworkQuality(n108);
-        if (p108 === PLVNetworkQuality.UNKNOWN) {
-            p108 = this.convertNetworkQuality(o108);
+        let s25 = this.convertNetworkQuality(q25);
+        if (s25 === PLVNetworkQuality.UNKNOWN) {
+            s25 = this.convertNetworkQuality(r25);
         }
-        this.mediator.linkmicNetworkQuality.setValue(p108);
+        this.mediator.linkmicNetworkQuality.setValue(s25);
     }
-    onNetworkStatistics(k108) {
-        const l108 = new PLVNetworkStatistics();
-        l108.upLossRate = k108.upLossRate;
-        l108.downLossRate = k108.downLossRate;
-        l108.upDelayMs = k108.upDelayMs;
-        l108.downDelayMs = k108.downDelayMs;
-        this.mediator.linkmicNetworkStatistics.setValue(l108);
+    onNetworkStatistics(n25) {
+        const o25 = new PLVNetworkStatistics();
+        o25.upLossRate = n25.upLossRate;
+        o25.downLossRate = n25.downLossRate;
+        o25.upDelayMs = n25.upDelayMs;
+        o25.downDelayMs = n25.downDelayMs;
+        this.mediator.linkmicNetworkStatistics.setValue(o25);
     }
-    onKickOut(code) {
-        const event = new PLVLinkMicRTCKickOut();
-        event.code = code;
-        this.mediator.rtcEvent.value = event;
+    onKickOut(l25) {
+        const m25 = new PLVLinkMicRTCKickOut();
+        m25.code = l25;
+        this.mediator.rtcEvent.value = m25;
     }
-    onError(code, message) {
-        this.mediator.reportError(PLVLinkMicErrorEvent.RTC_ENGINE_ERROR, `RTC engine error code:${code}, message:${message}`);
+    onError(j25, k25) {
+        this.mediator.reportError(PLVLinkMicErrorEvent.RTC_ENGINE_ERROR, `RTC engine error code:${j25}, message:${k25}`);
     }
-    convertNetworkQuality(j108) {
-        switch (j108) {
-            case PLVRTCNetworkQuality.EXCELLENT: return PLVNetworkQuality.EXCELLENT;
-            case PLVRTCNetworkQuality.GOOD: return PLVNetworkQuality.GOOD;
-            case PLVRTCNetworkQuality.POOR: return PLVNetworkQuality.POOR;
-            case PLVRTCNetworkQuality.BAD: return PLVNetworkQuality.BAD;
-            case PLVRTCNetworkQuality.VERY_BAD: return PLVNetworkQuality.VERY_BAD;
-            case PLVRTCNetworkQuality.DISCONNECT: return PLVNetworkQuality.DISCONNECT;
+    convertNetworkQuality(i25) {
+        switch (i25) {
+            case PLVRTCNetworkQuality.EXCELLENT:
+                return PLVNetworkQuality.EXCELLENT;
+            case PLVRTCNetworkQuality.GOOD:
+                return PLVNetworkQuality.GOOD;
+            case PLVRTCNetworkQuality.POOR:
+                return PLVNetworkQuality.POOR;
+            case PLVRTCNetworkQuality.BAD:
+                return PLVNetworkQuality.BAD;
+            case PLVRTCNetworkQuality.VERY_BAD:
+                return PLVNetworkQuality.VERY_BAD;
+            case PLVRTCNetworkQuality.DISCONNECT:
+                return PLVNetworkQuality.DISCONNECT;
             case PLVRTCNetworkQuality.UNKNOWN:
-            default: return PLVNetworkQuality.UNKNOWN;
+            default:
+                return PLVNetworkQuality.UNKNOWN;
         }
     }
 }

package/src/main/ets/modules/linkmic/model/PLVLinkMicRepo.d.ets

@@ -9,7 +9,7 @@ export declare class PLVLinkMicRepo implements LifecycleAwareDependComponent {
     private readonly networkDataSource;
     private readonly rtcConfig;
     private rtcEngine;
-    constructor(o110: PLVLinkMicMediator, p110: PLVLinkMicNetworkDataSource);
+    constructor(v28: PLVLinkMicMediator, w28: PLVLinkMicNetworkDataSource);
     init(): Promise<void>;
     private initLinkMicId;
     private initRtcEngine;
@@ -17,17 +17,17 @@ export declare class PLVLinkMicRepo implements LifecycleAwareDependComponent {
     private initLinkMicStrategy;
     getChannelLinkMicStatus(): Promise<PLVLinkMicChannelStatus>;
     sendLinkMicIdRelation(): Promise<void>;
-    sendLiveViewLog(u109: PLVLiveViewLogVO): Promise<void>;
+    sendLiveViewLog(z27: PLVLiveViewLogVO): Promise<void>;
     joinRTCChannel(): void;
-    switchRTCRole(role: PLVRTCClientRole): void;
-    enableLocalVideo(enable: boolean): void;
-    enableLocalAudio(enable: boolean): void;
+    switchRTCRole(w27: PLVRTCClientRole): void;
+    enableLocalVideo(v27: boolean): void;
+    enableLocalAudio(u27: boolean): void;
     switchCamera(): void;
-    setLocalVideoEncodeParam(param: PLVRTCVideoEncodeParam): void;
-    setVideoRender(param: PLVRTCVideoRenderParam): void;
-    getVideoRenderParam(r109: string): PLVRTCVideoRenderParam | null;
-    createRenderViewParam(q109: string): PLVRTCRenderViewParam | undefined;
-    getRemoteViewerMediaState(p109: string): PLVRTCMediaState | undefined;
+    setLocalVideoEncodeParam(t27: PLVRTCVideoEncodeParam): void;
+    setVideoRender(s27: PLVRTCVideoRenderParam): void;
+    getVideoRenderParam(r27: string): PLVRTCVideoRenderParam | null;
+    createRenderViewParam(q27: string): PLVRTCRenderViewParam | undefined;
+    getRemoteViewerMediaState(p27: string): PLVRTCMediaState | undefined;
     renewToken(): Promise<void>;
     leaveRTCChannel(): void;
     onDestroy(): Promise<void>;

package/src/main/ets/modules/linkmic/model/PLVLinkMicRepo.js

@@ -6,25 +6,25 @@ import { PLVLinkMicViewer } from './vo/PLVLinkMicViewer';
 import { PLVSocketUserBean } from '../../socket/model/PLVSocketUserBean';
 import { PLVLinkMicMode } from './vo/PLVLinkMicMode';
 export class PLVLinkMicRepo {
-    constructor(o110, p110) {
+    constructor(v28, w28) {
         this.rtcConfig = new PLVRTCConfig();
         this.rtcEngine = null;
-        this.mediator = o110;
-        this.networkDataSource = p110;
+        this.mediator = v28;
+        this.networkDataSource = w28;
     }
     async init() {
         this.initLinkMicId();
-        const token = await this.networkDataSource.getLinkMicToken();
-        this.initRtcEngine(token);
+        const u28 = await this.networkDataSource.getLinkMicToken();
+        this.initRtcEngine(u28);
         this.initLocalLinkMicViewer();
         this.initLinkMicStrategy();
     }
     initLinkMicId() {
-        const l110 = requireNotNull(this.mediator.channelData?.liveDetail?.rtcType);
-        if (l110 === PLVLinkMicRTCType.ARTC) {
-            const m110 = PLVSocketUserBean.isSpecialType(this.mediator.channelData?.viewerType);
-            const n110 = !Number.isNaN(Number.parseInt(requireNotNull(this.mediator.channelData?.viewerId)));
-            if (m110 && n110) {
+        const r28 = requireNotNull(this.mediator.channelData?.liveDetail?.rtcType);
+        if (r28 === PLVLinkMicRTCType.ARTC) {
+            const s28 = PLVSocketUserBean.isSpecialType(this.mediator.channelData?.viewerType);
+            const t28 = !Number.isNaN(Number.parseInt(requireNotNull(this.mediator.channelData?.viewerId)));
+            if (s28 && t28) {
                 this.mediator.linkmicId = requireNotNull(this.mediator.channelData?.viewerId);
             }
             else {
@@ -37,45 +37,49 @@ export class PLVLinkMicRepo {
         }
         requireNotNull(this.mediator.channelData).linkmicId = this.mediator.linkmicId;
     }
-    initRtcEngine(i110) {
-        const j110 = requireNotNull(this.mediator.channelData?.liveDetail?.rtcType);
-        switch (j110) {
+    initRtcEngine(o28) {
+        const p28 = requireNotNull(this.mediator.channelData?.liveDetail?.rtcType);
+        switch (p28) {
             case PLVLinkMicRTCType.ARTC:
                 this.rtcConfig.rtcType = PLVRTCType.ARTC;
                 break;
-            default: this.rtcConfig.rtcType = null;
+            case PLVLinkMicRTCType.TRTC:
+                this.rtcConfig.rtcType = PLVRTCType.TRTC;
+                break;
+            default:
+                this.rtcConfig.rtcType = null;
         }
         this.rtcConfig.context = getContext().getApplicationContext();
-        this.rtcConfig.rtcToken = i110;
+        this.rtcConfig.rtcToken = o28;
         this.rtcConfig.linkmicId = requireNotNull(this.mediator.linkmicId);
         this.rtcEngine = PLVRTCEngineFactory.create(this.rtcConfig, new PLVLinkMicRTCEventCallback(this.mediator));
-        const k110 = this.rtcConfig.rtcType !== null && this.rtcEngine.getSupportRTCTypes()
+        const q28 = this.rtcConfig.rtcType !== null && this.rtcEngine.getSupportRTCTypes()
             .includes(this.rtcConfig.rtcType);
-        this.mediator.sdkSupportChannelLinkMic.setValue(k110);
+        this.mediator.sdkSupportChannelLinkMic.setValue(q28);
     }
     initLocalLinkMicViewer() {
-        const e110 = requireNotNull(this.mediator.channelData?.loginChannelId);
-        const f110 = requireNotNull(this.mediator.linkmicId);
-        const g110 = requireNotNull(this.createRenderViewParam(f110));
-        const h110 = new PLVLinkMicViewer(e110, f110, g110.componentId, g110.componentLibraryName);
-        h110.viewerName.value = this.mediator.channelData?.viewerName;
-        h110.viewerId = this.mediator.channelData?.viewerId;
-        h110.viewerAvatar = this.mediator.channelData?.viewerAvatar;
-        h110.viewerActor = this.mediator.channelData?.viewerActor;
-        h110.viewerType = this.mediator.channelData?.viewerType;
-        h110.isMyself = true;
-        this.mediator.localLinkMicViewer.setValue(h110);
+        const k28 = requireNotNull(this.mediator.channelData?.loginChannelId);
+        const l28 = requireNotNull(this.mediator.linkmicId);
+        const m28 = requireNotNull(this.createRenderViewParam(l28));
+        const n28 = new PLVLinkMicViewer(k28, l28, m28.componentId, m28.componentLibraryName);
+        n28.viewerName.value = this.mediator.channelData?.viewerName;
+        n28.viewerId = this.mediator.channelData?.viewerId;
+        n28.viewerAvatar = this.mediator.channelData?.viewerAvatar;
+        n28.viewerActor = this.mediator.channelData?.viewerActor;
+        n28.viewerType = this.mediator.channelData?.viewerType;
+        n28.isMyself = true;
+        this.mediator.localLinkMicViewer.setValue(n28);
     }
     initLinkMicStrategy() {
-        const c110 = isLiteralTrue(this.mediator.channelData?.liveDetail?.newMicEnabled);
-        const d110 = this.mediator.channelData?.liveDetail?.defaultOpenMicLinkEnabled;
-        if (c110) {
-            if (d110 === 'audio') {
+        const i28 = isLiteralTrue(this.mediator.channelData?.liveDetail?.newMicEnabled);
+        const j28 = this.mediator.channelData?.liveDetail?.defaultOpenMicLinkEnabled;
+        if (i28) {
+            if (j28 === 'audio') {
                 this.mediator.channelAllowLinkMic.setValue(true);
                 this.mediator.isLinkMicStrategyV2.setValue(true);
                 this.mediator.channelLinkMicMode.setValue(PLVLinkMicMode.AUDIO);
             }
-            if (d110 === 'video') {
+            if (j28 === 'video') {
                 this.mediator.channelAllowLinkMic.setValue(true);
                 this.mediator.isLinkMicStrategyV2.setValue(true);
                 this.mediator.channelLinkMicMode.setValue(PLVLinkMicMode.VIDEO);
@@ -83,63 +87,63 @@ export class PLVLinkMicRepo {
         }
     }
     async getChannelLinkMicStatus() {
-        const a110 = requireNotNull(this.mediator.channelData);
-        const b110 = requireNotNull(a110.loginChannelId);
-        const sessionId = a110.sessionId ?? "";
-        return this.networkDataSource.getChannelLinkMicStatus(b110, sessionId);
+        const f28 = requireNotNull(this.mediator.channelData);
+        const g28 = requireNotNull(f28.loginChannelId);
+        const h28 = f28.sessionId ?? "";
+        return this.networkDataSource.getChannelLinkMicStatus(g28, h28);
     }
     async sendLinkMicIdRelation() {
-        const v109 = requireNotNull(this.mediator.channelData);
-        const w109 = v109.liveDetail?.rtcType;
-        const x109 = this.mediator.linkmicId;
-        if (w109 !== PLVLinkMicRTCType.ARTC || isNullOrUndefined(x109)) {
+        const a28 = requireNotNull(this.mediator.channelData);
+        const b28 = a28.liveDetail?.rtcType;
+        const c28 = this.mediator.linkmicId;
+        if (b28 !== PLVLinkMicRTCType.ARTC || isNullOrUndefined(c28)) {
             return;
         }
-        const y109 = requireNotNull(v109.loginChannelId);
-        const z109 = requireNotNull(v109.viewerId);
-        await this.networkDataSource.sendLinkMicIdRelation(y109, z109, x109);
+        const d28 = requireNotNull(a28.loginChannelId);
+        const e28 = requireNotNull(a28.viewerId);
+        await this.networkDataSource.sendLinkMicIdRelation(d28, e28, c28);
     }
-    async sendLiveViewLog(u109) {
-        await this.networkDataSource.sendLiveViewLog(u109);
+    async sendLiveViewLog(z27) {
+        await this.networkDataSource.sendLiveViewLog(z27);
     }
     joinRTCChannel() {
-        const s109 = requireNotNull(this.mediator.channelData);
-        const t109 = requireNotNull(s109.loginChannelId);
-        this.rtcEngine?.joinChannel(t109);
+        const x27 = requireNotNull(this.mediator.channelData);
+        const y27 = requireNotNull(x27.loginChannelId);
+        this.rtcEngine?.joinChannel(y27);
     }
-    switchRTCRole(role) {
-        this.rtcEngine?.switchRole(role);
+    switchRTCRole(w27) {
+        this.rtcEngine?.switchRole(w27);
     }
-    enableLocalVideo(enable) {
-        this.rtcEngine?.enableLocalVideoCapture(enable);
-        this.rtcEngine?.enableLocalVideoPublish(enable);
+    enableLocalVideo(v27) {
+        this.rtcEngine?.enableLocalVideoCapture(v27);
+        this.rtcEngine?.enableLocalVideoPublish(v27);
     }
-    enableLocalAudio(enable) {
-        this.rtcEngine?.enableLocalAudioCapture(enable);
-        this.rtcEngine?.enableLocalAudioPublish(enable);
+    enableLocalAudio(u27) {
+        this.rtcEngine?.enableLocalAudioCapture(u27);
+        this.rtcEngine?.enableLocalAudioPublish(u27);
     }
     switchCamera() {
         this.rtcEngine?.switchCamera();
     }
-    setLocalVideoEncodeParam(param) {
-        this.rtcEngine?.setLocalVideoEncodeParam(param);
+    setLocalVideoEncodeParam(t27) {
+        this.rtcEngine?.setLocalVideoEncodeParam(t27);
     }
-    setVideoRender(param) {
-        this.rtcEngine?.setVideoRender(param);
+    setVideoRender(s27) {
+        this.rtcEngine?.setVideoRender(s27);
     }
-    getVideoRenderParam(r109) {
-        return this.rtcEngine?.getVideoRenderParam(r109) ?? null;
+    getVideoRenderParam(r27) {
+        return this.rtcEngine?.getVideoRenderParam(r27) ?? null;
     }
-    createRenderViewParam(q109) {
-        return this.rtcEngine?.createRenderViewParam(q109);
+    createRenderViewParam(q27) {
+        return this.rtcEngine?.createRenderViewParam(q27);
     }
-    getRemoteViewerMediaState(p109) {
-        return this.rtcEngine?.getRemoteViewerMediaState(p109);
+    getRemoteViewerMediaState(p27) {
+        return this.rtcEngine?.getRemoteViewerMediaState(p27);
     }
     async renewToken() {
-        const token = await this.networkDataSource.getLinkMicToken();
-        this.rtcConfig.rtcToken = token;
-        this.rtcEngine?.renewToken(token);
+        const o27 = await this.networkDataSource.getLinkMicToken();
+        this.rtcConfig.rtcToken = o27;
+        this.rtcEngine?.renewToken(o27);
     }
     leaveRTCChannel() {
         this.rtcEngine?.leaveChannel();

package/src/main/ets/modules/linkmic/model/datasource/PLVLinkMicNetworkDataSource.d.ets

@@ -4,12 +4,13 @@ import { PLVLinkMicChannelStatus } from '../vo/PLVLinkMicChannelStatus';
 import { PLVLiveViewLogVO } from '../../../business/model/PLVLiveViewLogVO';
 export declare class PLVLinkMicNetworkDataSource {
     private readonly mediator;
-    constructor(o109: PLVLinkMicMediator);
-    getChannelLinkMicStatus(l109: string, sessionId: string): Promise<PLVLinkMicChannelStatus>;
+    constructor(n27: PLVLinkMicMediator);
+    getChannelLinkMicStatus(h27: string, i27: string): Promise<PLVLinkMicChannelStatus>;
     getLinkMicToken(): Promise<PLVRTCAppToken>;
-    sendLinkMicIdRelation(f109: string, g109: string, h109: string): Promise<void>;
-    sendLiveViewLog(e109: PLVLiveViewLogVO): Promise<void>;
+    sendLinkMicIdRelation(a27: string, b27: string, c27: string): Promise<void>;
+    sendLiveViewLog(z26: PLVLiveViewLogVO): Promise<void>;
     private getARTCLinkMicToken;
+    private getTRTCLinkMicToken;
     private createLinkMicStatisticsData;
     private get api_polyv_net();
     private get rtas_videocc_net();

package/src/main/ets/modules/linkmic/model/datasource/PLVLinkMicNetworkDataSource.js

@@ -9,74 +9,97 @@ import { PLVJSONUtils } from '@polyvharmony/live-scenes-foundation';
 import { PLVLinkMicChannelStatus } from '../vo/PLVLinkMicChannelStatus';
 import { rtasVideoNetApi } from '../../../net/PLVRtasVideoNetApi';
 export class PLVLinkMicNetworkDataSource {
-    constructor(o109) {
-        this.mediator = o109;
+    constructor(n27) {
+        this.mediator = n27;
     }
-    async getChannelLinkMicStatus(l109, sessionId) {
-        const m109 = requireNotNull(this.mediator.channelData);
-        const appId = requireNotNull(m109.appId);
-        const n109 = requireNotNull(m109.appSecret);
-        const response = await this.api_polyv_net.getChannelLinkMicStatus(appId, n109, l109, sessionId, true, "1");
-        require(response.status === 200
-            && response.data.code === 200
-            && response.data.data !== undefined, () => `getChannelLinkMicStatus failed: ${PLVJSONUtils.safeStringify(response)}`);
-        return plainToInstance(response.data.data, PLVLinkMicChannelStatus);
+    async getChannelLinkMicStatus(h27, i27) {
+        const j27 = requireNotNull(this.mediator.channelData);
+        const k27 = requireNotNull(j27.appId);
+        const l27 = requireNotNull(j27.appSecret);
+        const m27 = await this.api_polyv_net.getChannelLinkMicStatus(k27, l27, h27, i27, true, "1");
+        require(m27.status === 200
+            && m27.data.code === 200
+            && m27.data.data !== undefined, () => `getChannelLinkMicStatus failed: ${PLVJSONUtils.safeStringify(m27)}`);
+        return plainToInstance(m27.data.data, PLVLinkMicChannelStatus);
     }
     async getLinkMicToken() {
-        const k109 = this.mediator.channelData?.liveDetail?.rtcType;
-        switch (k109) {
-            case PLVLinkMicRTCType.ARTC: return this.getARTCLinkMicToken();
-            default: error(`Unknown linkmic rtc type ${k109}`);
+        const g27 = this.mediator.channelData?.liveDetail?.rtcType;
+        switch (g27) {
+            case PLVLinkMicRTCType.ARTC:
+                return this.getARTCLinkMicToken();
+            case PLVLinkMicRTCType.TRTC:
+                return this.getTRTCLinkMicToken();
+            default:
+                error(`Unknown linkmic rtc type ${g27}`);
         }
     }
-    async sendLinkMicIdRelation(f109, g109, h109) {
-        const i109 = requireNotNull(this.mediator.channelData);
-        const appId = requireNotNull(i109.appId);
-        const j109 = requireNotNull(i109.appSecret);
-        return this.api_polyv_net.reportARTCLinkMicRelation(appId, j109, f109, g109, h109);
+    async sendLinkMicIdRelation(a27, b27, c27) {
+        const d27 = requireNotNull(this.mediator.channelData);
+        const e27 = requireNotNull(d27.appId);
+        const f27 = requireNotNull(d27.appSecret);
+        return this.api_polyv_net.reportARTCLinkMicRelation(e27, f27, a27, b27, c27);
     }
-    async sendLiveViewLog(e109) {
-        await this.rtas_videocc_net.sendLiveViewLog(e109);
+    async sendLiveViewLog(z26) {
+        await this.rtas_videocc_net.sendLiveViewLog(z26);
     }
     async getARTCLinkMicToken() {
-        const z108 = requireNotNull(this.mediator.channelData);
-        const appId = requireNotNull(z108.appId);
-        const a109 = requireNotNull(z108.appSecret);
-        const b109 = requireNotNull(z108.loginChannelId);
-        const c109 = this.createLinkMicStatisticsData();
-        const response = await this.api_polyv_net.getARTCMicAuth(appId, a109, b109, c109);
-        require(response.status === 200
-            && response.data.code === 200
-            && response.data.data !== undefined, () => `ARTC mic auth response failure: ${PLVJSONUtils.safeStringify(response)}`);
-        const d109 = response.data.data;
-        const k = decodeFromBase64("cG9seXZsaXZlU0RLQXV0aA==");
-        const v = decodeFromBase64("MTExMTAwMDAxMTExMDAwMA==");
-        const result = decodeFromJsonPlain(decodeFromBase64(decryptAES(d109, k, v)));
+        const p26 = requireNotNull(this.mediator.channelData);
+        const q26 = requireNotNull(p26.appId);
+        const r26 = requireNotNull(p26.appSecret);
+        const s26 = requireNotNull(p26.loginChannelId);
+        const t26 = this.createLinkMicStatisticsData();
+        const u26 = await this.api_polyv_net.getARTCMicAuth(q26, r26, s26, t26);
+        require(u26.status === 200
+            && u26.data.code === 200
+            && u26.data.data !== undefined, () => `ARTC mic auth response failure: ${PLVJSONUtils.safeStringify(u26)}`);
+        const v26 = u26.data.data;
+        const w26 = decodeFromBase64("cG9seXZsaXZlU0RLQXV0aA==");
+        const x26 = decodeFromBase64("MTExMTAwMDAxMTExMDAwMA==");
+        const y26 = decodeFromJsonPlain(decodeFromBase64(decryptAES(v26, w26, x26)));
         return {
-            appId: requireNotNull(result.connect_appId),
-            token: requireNotNull(result.connect_channel_key)
+            appId: requireNotNull(y26.connect_appId),
+            token: requireNotNull(y26.connect_channel_key)
+        };
+    }
+    async getTRTCLinkMicToken() {
+        const f26 = requireNotNull(this.mediator.channelData);
+        const g26 = requireNotNull(f26.appId);
+        const h26 = requireNotNull(f26.appSecret);
+        const i26 = requireNotNull(f26.loginChannelId);
+        const j26 = this.createLinkMicStatisticsData();
+        const k26 = await this.api_polyv_net.getTRTCMicAuth(g26, h26, i26, j26);
+        require(k26.status === 200
+            && k26.data.code === 200
+            && k26.data.data !== undefined, () => `TRTC mic auth response failure: ${PLVJSONUtils.safeStringify(k26)}`);
+        const l26 = k26.data.data;
+        const m26 = decodeFromBase64("cG9seXZsaXZlU0RLQXV0aA==");
+        const n26 = decodeFromBase64("MTExMTAwMDAxMTExMDAwMA==");
+        const o26 = decodeFromJsonPlain(decodeFromBase64(decryptAES(l26, m26, n26)));
+        return {
+            sdkAppId: requireNotNull(o26.sdkAppId),
+            userSig: requireNotNull(o26.userSign)
         };
     }
     createLinkMicStatisticsData() {
-        const y108 = requireNotNull(this.mediator.channelData);
-        const data = new PLVLinkMicTokenRequestStatisticsData();
-        data.uid = requireNotNull(this.mediator.linkmicId);
-        data.channelId = requireNotNull(y108.loginChannelId);
-        data.scene = y108.channelType ?? "";
-        data.userType = requireNotNull(y108.viewerType);
-        data.viewerId = requireNotNull(y108.viewerId);
-        data.nickname = requireNotNull(y108.viewerName);
-        data.client = "Harmony SDK";
-        data.clientVersion = BuildProfile.HAR_VERSION;
-        data.clientTs = Date.now().toString();
-        data.sessionId = y108.sessionId ?? "";
-        data.deviceType = "phone";
-        data.model = deviceInfo.productModel;
-        data.os = "HarmonyOS";
-        data.osVersion = deviceInfo.osFullName;
-        data.screenWidth = display.getDefaultDisplaySync().width.toString();
-        data.screenHeight = display.getDefaultDisplaySync().height.toString();
-        return data;
+        const d26 = requireNotNull(this.mediator.channelData);
+        const e26 = new PLVLinkMicTokenRequestStatisticsData();
+        e26.uid = requireNotNull(this.mediator.linkmicId);
+        e26.channelId = requireNotNull(d26.loginChannelId);
+        e26.scene = d26.channelType ?? "";
+        e26.userType = requireNotNull(d26.viewerType);
+        e26.viewerId = requireNotNull(d26.viewerId);
+        e26.nickname = requireNotNull(d26.viewerName);
+        e26.client = "Harmony SDK";
+        e26.clientVersion = BuildProfile.HAR_VERSION;
+        e26.clientTs = Date.now().toString();
+        e26.sessionId = d26.sessionId ?? "";
+        e26.deviceType = "phone";
+        e26.model = deviceInfo.productModel;
+        e26.os = "HarmonyOS";
+        e26.osVersion = deviceInfo.osFullName;
+        e26.screenWidth = display.getDefaultDisplaySync().width.toString();
+        e26.screenHeight = display.getDefaultDisplaySync().height.toString();
+        return e26;
     }
     get api_polyv_net() {
         return apiPlvNetApi(requireNotNull(this.mediator.channelData));

package/src/main/ets/modules/linkmic/model/vo/PLVLinkMicBitRate.d.ets

@@ -1,7 +1,7 @@
 export declare class PLVLinkMicBitRate {
     readonly index: number;
     readonly name: string | Resource;
-    constructor(index: number, name: string | Resource);
+    constructor(x28: number, y28: string | Resource);
     get nameString(): string;
     static STANDARD: PLVLinkMicBitRate;
     static HIGH: PLVLinkMicBitRate;

package/src/main/ets/modules/linkmic/model/vo/PLVLinkMicBitRate.js

@@ -1,8 +1,8 @@
 import { PLVMediaPlayerAppContext } from '@polyvharmony/media-player-sdk';
 export class PLVLinkMicBitRate {
-    constructor(index, name) {
-        this.index = index;
-        this.name = name;
+    constructor(x28, y28) {
+        this.index = x28;
+        this.name = y28;
     }
     get nameString() {
         if (typeof this.name === 'string') {

package/src/main/ets/modules/linkmic/model/vo/PLVLinkMicBitRateEncodeParam.d.ets

@@ -11,6 +11,6 @@ export declare class PLVLinkMicBitRateEncodeParam {
     readonly screenWidth: number;
     readonly screenHeight: number;
     readonly screenBitrate: number;
-    constructor(bitRate: PLVLinkMicBitRate, q110: number, r110: number, videoWidth: number, videoHeight: number, videoBitrate: number, s110: number, t110: number, screenWidth: number, screenHeight: number, u110: number);
+    constructor(z28: PLVLinkMicBitRate, a29: number, b29: number, c29: number, d29: number, e29: number, f29: number, g29: number, h29: number, i29: number, j29: number);
 }
 export declare const DEFAULT_BITRATE_ENCODE_PARAM_TABLE: PLVLinkMicBitRateEncodeParam[];

package/src/main/ets/modules/linkmic/model/vo/PLVLinkMicBitRateEncodeParam.js

@@ -1,17 +1,17 @@
 import { PLVLinkMicBitRate } from './PLVLinkMicBitRate';
 export class PLVLinkMicBitRateEncodeParam {
-    constructor(bitRate, q110, r110, videoWidth, videoHeight, videoBitrate, s110, t110, screenWidth, screenHeight, u110) {
-        this.bitRate = bitRate;
-        this.videoFps = q110;
-        this.videoGop = r110;
-        this.videoWidth = videoWidth;
-        this.videoHeight = videoHeight;
-        this.videoBitrate = videoBitrate;
-        this.screenFps = s110;
-        this.screenGop = t110;
-        this.screenWidth = screenWidth;
-        this.screenHeight = screenHeight;
-        this.screenBitrate = u110;
+    constructor(z28, a29, b29, c29, d29, e29, f29, g29, h29, i29, j29) {
+        this.bitRate = z28;
+        this.videoFps = a29;
+        this.videoGop = b29;
+        this.videoWidth = c29;
+        this.videoHeight = d29;
+        this.videoBitrate = e29;
+        this.screenFps = f29;
+        this.screenGop = g29;
+        this.screenWidth = h29;
+        this.screenHeight = i29;
+        this.screenBitrate = j29;
     }
 }
 export const DEFAULT_BITRATE_ENCODE_PARAM_TABLE = [

package/src/main/ets/modules/linkmic/model/vo/PLVLinkMicErrorEvent.d.ets

@@ -13,5 +13,5 @@ export declare class PLVLinkMicErrorEvent {
     static readonly RTC_ENGINE_ERROR = 10;
     readonly code: number;
     readonly message: string;
-    constructor(code: number, message: string);
+    constructor(k29: number, l29: string);
 }

package/src/main/ets/modules/linkmic/model/vo/PLVLinkMicErrorEvent.js

@@ -1,7 +1,7 @@
 export class PLVLinkMicErrorEvent {
-    constructor(code, message) {
-        this.code = code;
-        this.message = message;
+    constructor(k29, l29) {
+        this.code = k29;
+        this.message = l29;
     }
 }
 PLVLinkMicErrorEvent.LINKMIC_INIT_FAILED = 1;

package/src/main/ets/modules/linkmic/model/vo/PLVLinkMicInteractEvent.d.ets

@@ -2,5 +2,5 @@ import { PLVMemberChannelViewer } from "../../../member/model/vo/PLVMemberChanne
 export declare class PLVLinkMicAnswerInvitationEvent {
     readonly viewer: PLVMemberChannelViewer;
     readonly accept: boolean;
-    constructor(v110: PLVMemberChannelViewer, accept: boolean);
+    constructor(m29: PLVMemberChannelViewer, n29: boolean);
 }