@polyvharmony/live-scenes-sdk 1.2.0-rc.1

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

@@ -0,0 +1,87 @@
+import { PLVLogger } from '@polyvharmony/live-scenes-foundation';
+import { isNullOrUndefined, MutableEvent, MutableSource, MutableState, Promises } from '@polyvharmony/media-player-sdk';
+import { PLVPushDowngradePreference, PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+import { PLVNetworkQuality } from '../../net/vo/PLVNetworkQuality';
+import { PLVLinkMicBitRate } from '../model/vo/PLVLinkMicBitRate';
+import { PLVLinkMicCameraFacing } from '../model/vo/PLVLinkMicCameraFacing';
+import { PLVLinkMicErrorEvent } from '../model/vo/PLVLinkMicErrorEvent';
+import { PLVLinkMicPushResolutionRatio } from '../model/vo/PLVLinkMicPushResolutionRatio';
+import { PLVLinkMicState } from '../model/vo/PLVLinkMicState';
+const TAG = 'PLVLinkMicManager';
+export class PLVLinkMicMediator {
+    constructor() {
+        this.channelData = null;
+        this.socketMediator = null;
+        this.playerMediator = null;
+        this.memberMediator = null;
+        this.initFinish = Promises.withResolvers();
+        this.linkmicState = new MutableState(PLVLinkMicState.NoLinkMic);
+        this.joinLinkMicWaitingQueueOrder = new MutableState(-1);
+        this.invitationExpireTimestamp = new MutableState();
+        this.sdkSupportChannelLinkMic = new MutableState(false);
+        this.channelAllowLinkMic = new MutableState(false);
+        this.channelAllowRequestHandsUpLinkMic = new MutableState(false);
+        this.channelLinkMicMode = new MutableState();
+        this.localLinkMicViewer = new MutableState();
+        this.channelLinkMicViewers = new MutableState();
+        this.channelMainViewLinkMicId = new MutableState(undefined);
+        this.linkmicNetworkQuality = new MutableState(PLVNetworkQuality.UNKNOWN);
+        this.linkmicNetworkStatistics = new MutableState();
+        this.currentPushResolutionRatio = new MutableState(PLVLinkMicPushResolutionRatio.RATIO_16_9);
+        this.currentPushOrientation = new MutableState(PLVPushOrientation.AUTO);
+        this.currentBitRate = new MutableState(PLVLinkMicBitRate.STANDARD);
+        this.channelSupportBitRates = new MutableState([PLVLinkMicBitRate.STANDARD]);
+        this.currentBitRateEncodeParam = new MutableState();
+        this.channelSupportBitRateEncodeParams = new MutableState();
+        this.currentPushDowngradePreference = new MutableState(PLVPushDowngradePreference.PREFER_BETTER_QUALITY);
+        this.cameraFacing = new MutableState(PLVLinkMicCameraFacing.FRONT);
+        this.localRenderMirror = new MutableState(false);
+        this.currentPushMirror = new MutableState(false);
+        this.isLinkMicStrategyV2 = new MutableState(false);
+        this.rtcEvent = new MutableEvent();
+        this.teacherHangUpLinkMicEvent = new MutableEvent();
+        this.viewerJoinLinkMicEvent = new MutableEvent();
+        this.viewerLeaveLinkMicEvent = new MutableEvent();
+        this.viewerAnswerInvitationEvent = new MutableEvent();
+        this.errorEvent = new MutableEvent();
+        this.linkmicId = undefined;
+        this.linkmicIdDifferFromViewerId = false;
+        this.onStreamerStart = undefined;
+        this.onLiveStreamStart = undefined;
+        this.onLiveStreamStop = undefined;
+        this.onStreamerStop = undefined;
+        this.setBitRate = undefined;
+        this.setPushResolutionRatio = undefined;
+        this.setPushOrientation = undefined;
+        this.setPushDowngradePreference = undefined;
+    }
+    reportError(code, message) {
+        this.errorEvent.value = new PLVLinkMicErrorEvent(code, message);
+        PLVLogger.error(TAG, `Linkmic module error, code:${code}, message:${message}`, true);
+    }
+    isMySocketLinkMicId(userId) {
+        const p127 = this.linkmicId;
+        const q127 = this.channelData?.viewerId;
+        if (this.linkmicIdDifferFromViewerId) {
+            return q127 === userId || p127 === userId;
+        }
+        else {
+            return q127 === userId;
+        }
+    }
+    findViewerByLinkMicId(m127) {
+        if (isNullOrUndefined(m127)) {
+            return undefined;
+        }
+        return this.channelLinkMicViewers.value?.find(o127 => o127.linkmicId === m127);
+    }
+    findViewerByViewerId(j127) {
+        if (isNullOrUndefined(j127)) {
+            return undefined;
+        }
+        return this.channelLinkMicViewers.value?.find(l127 => l127.viewerId === j127);
+    }
+    onDestroy() {
+        MutableSource.disposeAll(this);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { PLVRTCConfig, PLVRTCEngineEventCallback, PLVRTCMediaState, PLVRTCNetworkQuality, PLVRTCNetworkStatistics } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicMediator } from './PLVLinkMicMediator';
+export declare class PLVLinkMicRTCEventCallback extends PLVRTCEngineEventCallback {
+    private readonly mediator;
+    constructor(f128: PLVLinkMicMediator);
+    onJoinChannelSuccess(d128: PLVRTCConfig, e128: string): void;
+    onRemoteUserMediaStateChanged(a128: string, b128: PLVRTCMediaState): void;
+    onTokenExpired(y127: string | undefined, z127: PLVRTCConfig): void;
+    onNetworkQuality(u127: string, v127: PLVRTCNetworkQuality, w127: PLVRTCNetworkQuality): void;
+    onNetworkStatistics(s127: PLVRTCNetworkStatistics): void;
+    onKickOut(code: number): void;
+    onError(code: number, message: string): void;
+    private convertNetworkQuality;
+}

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

@@ -0,0 +1,69 @@
+import { PLVRTCEngineEventCallback, PLVRTCNetworkQuality } from '@polyvharmony/rtc-sdk';
+import { PLVNetworkQuality } from '../../net/vo/PLVNetworkQuality';
+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(f128) {
+        super();
+        this.mediator = f128;
+    }
+    onJoinChannelSuccess(d128, e128) {
+        const event = new PLVLinkMicRTCJoinSuccess();
+        event.rtcConfig = d128;
+        event.channelId = e128;
+        this.mediator.rtcEvent.value = event;
+    }
+    onRemoteUserMediaStateChanged(a128, b128) {
+        const c128 = this.mediator.findViewerByLinkMicId(b128.linkmicId);
+        if (c128) {
+            c128.isVideoEnable.setValue(b128.videoEnable);
+            c128.isAudioEnable.setValue(b128.audioEnable);
+            c128.audioVolume.setValue(b128.audioVolume);
+        }
+    }
+    onTokenExpired(y127, z127) {
+        const event = new PLVLinkMicRTCTokenExpired();
+        event.rtcConfig = z127;
+        event.channelId = y127;
+        this.mediator.rtcEvent.value = event;
+    }
+    onNetworkQuality(u127, v127, w127) {
+        if (u127 !== this.mediator.linkmicId) {
+            return;
+        }
+        let x127 = this.convertNetworkQuality(v127);
+        if (x127 === PLVNetworkQuality.UNKNOWN) {
+            x127 = this.convertNetworkQuality(w127);
+        }
+        this.mediator.linkmicNetworkQuality.setValue(x127);
+    }
+    onNetworkStatistics(s127) {
+        const t127 = new PLVNetworkStatistics();
+        t127.upLossRate = s127.upLossRate;
+        t127.downLossRate = s127.downLossRate;
+        t127.upDelayMs = s127.upDelayMs;
+        t127.downDelayMs = s127.downDelayMs;
+        this.mediator.linkmicNetworkStatistics.setValue(t127);
+    }
+    onKickOut(code) {
+        const event = new PLVLinkMicRTCKickOut();
+        event.code = code;
+        this.mediator.rtcEvent.value = event;
+    }
+    onError(code, message) {
+        this.mediator.reportError(PLVLinkMicErrorEvent.RTC_ENGINE_ERROR, `RTC engine error code:${code}, message:${message}`);
+    }
+    convertNetworkQuality(r127) {
+        switch (r127) {
+            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;
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicMediator } from '../mediator/PLVLinkMicMediator';
+import { PLVLinkMicNetworkDataSource } from './datasource/PLVLinkMicNetworkDataSource';
+import { PLVRTCClientRole, PLVRTCMediaState, PLVRTCRenderViewParam, PLVRTCVideoEncodeParam, PLVRTCVideoRenderParam } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicChannelStatus } from './vo/PLVLinkMicChannelStatus';
+import { PLVLiveViewLogVO } from '../../business/model/PLVLiveViewLogVO';
+export declare class PLVLinkMicRepo implements LifecycleAwareDependComponent {
+    readonly mediator: PLVLinkMicMediator;
+    private readonly networkDataSource;
+    private readonly rtcConfig;
+    private rtcEngine;
+    constructor(y129: PLVLinkMicMediator, z129: PLVLinkMicNetworkDataSource);
+    init(): Promise<void>;
+    private initLinkMicId;
+    private initRtcEngine;
+    private initLocalLinkMicViewer;
+    private initLinkMicStrategy;
+    getChannelLinkMicStatus(): Promise<PLVLinkMicChannelStatus>;
+    sendLinkMicIdRelation(): Promise<void>;
+    sendLiveViewLog(e129: PLVLiveViewLogVO): Promise<void>;
+    joinRTCChannel(): void;
+    switchRTCRole(role: PLVRTCClientRole): void;
+    enableLocalVideo(enable: boolean): void;
+    enableLocalAudio(enable: boolean): void;
+    switchCamera(): void;
+    setLocalVideoEncodeParam(param: PLVRTCVideoEncodeParam): void;
+    setVideoRender(param: PLVRTCVideoRenderParam): void;
+    getVideoRenderParam(b129: string): PLVRTCVideoRenderParam | null;
+    createRenderViewParam(a129: string): PLVRTCRenderViewParam | undefined;
+    getRemoteViewerMediaState(z128: string): PLVRTCMediaState | undefined;
+    renewToken(): Promise<void>;
+    leaveRTCChannel(): void;
+    onDestroy(): Promise<void>;
+}

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

@@ -0,0 +1,151 @@
+import { isLiteralTrue, isNullOrUndefined, requireNotNull } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicRTCType } from './vo/PLVLinkMicRTCType';
+import { PLVRTCConfig, PLVRTCEngineFactory, PLVRTCType } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicRTCEventCallback } from '../mediator/PLVLinkMicRTCEventCallback';
+import { PLVLinkMicViewer } from './vo/PLVLinkMicViewer';
+import { PLVSocketUserBean } from '../../socket/model/PLVSocketUserBean';
+import { PLVLinkMicMode } from './vo/PLVLinkMicMode';
+export class PLVLinkMicRepo {
+    constructor(y129, z129) {
+        this.rtcConfig = new PLVRTCConfig();
+        this.rtcEngine = null;
+        this.mediator = y129;
+        this.networkDataSource = z129;
+    }
+    async init() {
+        this.initLinkMicId();
+        const token = await this.networkDataSource.getLinkMicToken();
+        this.initRtcEngine(token);
+        this.initLocalLinkMicViewer();
+        this.initLinkMicStrategy();
+    }
+    initLinkMicId() {
+        const v129 = requireNotNull(this.mediator.channelData?.liveDetail?.rtcType);
+        if (v129 === PLVLinkMicRTCType.ARTC) {
+            const w129 = PLVSocketUserBean.isSpecialType(this.mediator.channelData?.viewerType);
+            const x129 = !Number.isNaN(Number.parseInt(requireNotNull(this.mediator.channelData?.viewerId)));
+            if (w129 && x129) {
+                this.mediator.linkmicId = requireNotNull(this.mediator.channelData?.viewerId);
+            }
+            else {
+                this.mediator.linkmicId = Math.abs(Date.now() & 0xFFFFFFFF).toString();
+                this.mediator.linkmicIdDifferFromViewerId = true;
+            }
+        }
+        else {
+            this.mediator.linkmicId = requireNotNull(this.mediator.channelData?.viewerId);
+        }
+        requireNotNull(this.mediator.channelData).linkmicId = this.mediator.linkmicId;
+    }
+    initRtcEngine(s129) {
+        const t129 = requireNotNull(this.mediator.channelData?.liveDetail?.rtcType);
+        switch (t129) {
+            case PLVLinkMicRTCType.ARTC:
+                this.rtcConfig.rtcType = PLVRTCType.ARTC;
+                break;
+            default: this.rtcConfig.rtcType = null;
+        }
+        this.rtcConfig.context = getContext().getApplicationContext();
+        this.rtcConfig.rtcToken = s129;
+        this.rtcConfig.linkmicId = requireNotNull(this.mediator.linkmicId);
+        this.rtcEngine = PLVRTCEngineFactory.create(this.rtcConfig, new PLVLinkMicRTCEventCallback(this.mediator));
+        const u129 = this.rtcConfig.rtcType !== null && this.rtcEngine.getSupportRTCTypes()
+            .includes(this.rtcConfig.rtcType);
+        this.mediator.sdkSupportChannelLinkMic.setValue(u129);
+    }
+    initLocalLinkMicViewer() {
+        const o129 = requireNotNull(this.mediator.channelData?.loginChannelId);
+        const p129 = requireNotNull(this.mediator.linkmicId);
+        const q129 = requireNotNull(this.createRenderViewParam(p129));
+        const r129 = new PLVLinkMicViewer(o129, p129, q129.componentId, q129.componentLibraryName);
+        r129.viewerName.value = this.mediator.channelData?.viewerName;
+        r129.viewerId = this.mediator.channelData?.viewerId;
+        r129.viewerAvatar = this.mediator.channelData?.viewerAvatar;
+        r129.viewerActor = this.mediator.channelData?.viewerActor;
+        r129.viewerType = this.mediator.channelData?.viewerType;
+        r129.isMyself = true;
+        this.mediator.localLinkMicViewer.setValue(r129);
+    }
+    initLinkMicStrategy() {
+        const m129 = isLiteralTrue(this.mediator.channelData?.liveDetail?.newMicEnabled);
+        const n129 = this.mediator.channelData?.liveDetail?.defaultOpenMicLinkEnabled;
+        if (m129) {
+            if (n129 === 'audio') {
+                this.mediator.channelAllowLinkMic.setValue(true);
+                this.mediator.isLinkMicStrategyV2.setValue(true);
+                this.mediator.channelLinkMicMode.setValue(PLVLinkMicMode.AUDIO);
+            }
+            if (n129 === 'video') {
+                this.mediator.channelAllowLinkMic.setValue(true);
+                this.mediator.isLinkMicStrategyV2.setValue(true);
+                this.mediator.channelLinkMicMode.setValue(PLVLinkMicMode.VIDEO);
+            }
+        }
+    }
+    async getChannelLinkMicStatus() {
+        const k129 = requireNotNull(this.mediator.channelData);
+        const l129 = requireNotNull(k129.loginChannelId);
+        const sessionId = k129.sessionId ?? "";
+        return this.networkDataSource.getChannelLinkMicStatus(l129, sessionId);
+    }
+    async sendLinkMicIdRelation() {
+        const f129 = requireNotNull(this.mediator.channelData);
+        const g129 = f129.liveDetail?.rtcType;
+        const h129 = this.mediator.linkmicId;
+        if (g129 !== PLVLinkMicRTCType.ARTC || isNullOrUndefined(h129)) {
+            return;
+        }
+        const i129 = requireNotNull(f129.loginChannelId);
+        const j129 = requireNotNull(f129.viewerId);
+        await this.networkDataSource.sendLinkMicIdRelation(i129, j129, h129);
+    }
+    async sendLiveViewLog(e129) {
+        await this.networkDataSource.sendLiveViewLog(e129);
+    }
+    joinRTCChannel() {
+        const c129 = requireNotNull(this.mediator.channelData);
+        const d129 = requireNotNull(c129.loginChannelId);
+        this.rtcEngine?.joinChannel(d129);
+    }
+    switchRTCRole(role) {
+        this.rtcEngine?.switchRole(role);
+    }
+    enableLocalVideo(enable) {
+        this.rtcEngine?.enableLocalVideoCapture(enable);
+        this.rtcEngine?.enableLocalVideoPublish(enable);
+    }
+    enableLocalAudio(enable) {
+        this.rtcEngine?.enableLocalAudioCapture(enable);
+        this.rtcEngine?.enableLocalAudioPublish(enable);
+    }
+    switchCamera() {
+        this.rtcEngine?.switchCamera();
+    }
+    setLocalVideoEncodeParam(param) {
+        this.rtcEngine?.setLocalVideoEncodeParam(param);
+    }
+    setVideoRender(param) {
+        this.rtcEngine?.setVideoRender(param);
+    }
+    getVideoRenderParam(b129) {
+        return this.rtcEngine?.getVideoRenderParam(b129) ?? null;
+    }
+    createRenderViewParam(a129) {
+        return this.rtcEngine?.createRenderViewParam(a129);
+    }
+    getRemoteViewerMediaState(z128) {
+        return this.rtcEngine?.getRemoteViewerMediaState(z128);
+    }
+    async renewToken() {
+        const token = await this.networkDataSource.getLinkMicToken();
+        this.rtcConfig.rtcToken = token;
+        this.rtcEngine?.renewToken(token);
+    }
+    leaveRTCChannel() {
+        this.rtcEngine?.leaveChannel();
+    }
+    async onDestroy() {
+        await this.mediator.initFinish.promise;
+        this.rtcEngine?.destroy();
+    }
+}

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

@@ -0,0 +1,16 @@
+import { PLVLinkMicMediator } from '../../mediator/PLVLinkMicMediator';
+import { PLVRTCAppToken } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicChannelStatus } from '../vo/PLVLinkMicChannelStatus';
+import { PLVLiveViewLogVO } from '../../../business/model/PLVLiveViewLogVO';
+export declare class PLVLinkMicNetworkDataSource {
+    private readonly mediator;
+    constructor(y128: PLVLinkMicMediator);
+    getChannelLinkMicStatus(u128: string, sessionId: string): Promise<PLVLinkMicChannelStatus>;
+    getLinkMicToken(): Promise<PLVRTCAppToken>;
+    sendLinkMicIdRelation(o128: string, p128: string, q128: string): Promise<void>;
+    sendLiveViewLog(n128: PLVLiveViewLogVO): Promise<void>;
+    private getARTCLinkMicToken;
+    private createLinkMicStatisticsData;
+    private get api_polyv_net();
+    private get rtas_videocc_net();
+}

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

@@ -0,0 +1,87 @@
+import { decodeFromBase64, decodeFromJsonPlain, decryptAES, error, plainToInstance, require, requireNotNull } from '@polyvharmony/media-player-sdk';
+import { apiPlvNetApi } from '../../../net/PLVApiPlvNetApi';
+import { PLVLinkMicTokenRequestStatisticsData } from '../vo/PLVLinkMicTokenRequestStatisticsData';
+import BuildProfile from '../../../../../../../BuildProfile';
+import deviceInfo from '@ohos.deviceInfo';
+import display from "@ohos.display";
+import { PLVLinkMicRTCType } from '../vo/PLVLinkMicRTCType';
+import { PLVJSONUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVLinkMicChannelStatus } from '../vo/PLVLinkMicChannelStatus';
+import { rtasVideoNetApi } from '../../../net/PLVRtasVideoNetApi';
+export class PLVLinkMicNetworkDataSource {
+    constructor(y128) {
+        this.mediator = y128;
+    }
+    async getChannelLinkMicStatus(u128, sessionId) {
+        const v128 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(v128.appId);
+        const w128 = requireNotNull(v128.appSecret);
+        const response = await this.api_polyv_net.getChannelLinkMicStatus(appId, w128, u128, 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 getLinkMicToken() {
+        const t128 = this.mediator.channelData?.liveDetail?.rtcType;
+        switch (t128) {
+            case PLVLinkMicRTCType.ARTC: return this.getARTCLinkMicToken();
+            default: error(`Unknown linkmic rtc type ${t128}`);
+        }
+    }
+    async sendLinkMicIdRelation(o128, p128, q128) {
+        const r128 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(r128.appId);
+        const s128 = requireNotNull(r128.appSecret);
+        return this.api_polyv_net.reportARTCLinkMicRelation(appId, s128, o128, p128, q128);
+    }
+    async sendLiveViewLog(n128) {
+        await this.rtas_videocc_net.sendLiveViewLog(n128);
+    }
+    async getARTCLinkMicToken() {
+        const h128 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(h128.appId);
+        const i128 = requireNotNull(h128.appSecret);
+        const j128 = requireNotNull(h128.loginChannelId);
+        const k128 = this.createLinkMicStatisticsData();
+        const response = await this.api_polyv_net.getARTCMicAuth(appId, i128, j128, k128);
+        require(response.status === 200
+            && response.data.code === 200
+            && response.data.data !== undefined, () => `ARTC mic auth response failure: ${PLVJSONUtils.safeStringify(response)}`);
+        const l128 = response.data.data;
+        const k = decodeFromBase64("cG9seXZsaXZlU0RLQXV0aA==");
+        const v = decodeFromBase64("MTExMTAwMDAxMTExMDAwMA==");
+        const result = decodeFromJsonPlain(decodeFromBase64(decryptAES(l128, k, v)));
+        return {
+            appId: requireNotNull(result.connect_appId),
+            token: requireNotNull(result.connect_channel_key)
+        };
+    }
+    createLinkMicStatisticsData() {
+        const g128 = requireNotNull(this.mediator.channelData);
+        const data = new PLVLinkMicTokenRequestStatisticsData();
+        data.uid = requireNotNull(this.mediator.linkmicId);
+        data.channelId = requireNotNull(g128.loginChannelId);
+        data.scene = g128.channelType ?? "";
+        data.userType = requireNotNull(g128.viewerType);
+        data.viewerId = requireNotNull(g128.viewerId);
+        data.nickname = requireNotNull(g128.viewerName);
+        data.client = "Harmony SDK";
+        data.clientVersion = BuildProfile.HAR_VERSION;
+        data.clientTs = Date.now().toString();
+        data.sessionId = g128.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;
+    }
+    get api_polyv_net() {
+        return apiPlvNetApi(requireNotNull(this.mediator.channelData));
+    }
+    get rtas_videocc_net() {
+        return rtasVideoNetApi(requireNotNull(this.mediator.channelData));
+    }
+}

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

@@ -0,0 +1,10 @@
+export declare class PLVLinkMicBitRate {
+    readonly index: number;
+    readonly name: string | Resource;
+    constructor(index: number, name: string | Resource);
+    get nameString(): string;
+    static STANDARD: PLVLinkMicBitRate;
+    static HIGH: PLVLinkMicBitRate;
+    static SUPER: PLVLinkMicBitRate;
+    static SUPER_HIGH: PLVLinkMicBitRate;
+}

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

@@ -0,0 +1,34 @@
+var __decorate = (this && this.__decorate) || function (b130, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(b130, target, key, desc);
+    else
+        for (var c130 = b130.length - 1; c130 >= 0; c130--)
+            if (d = b130[c130])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var PLVLinkMicBitRate_1;
+import { MixinToRaw, PLVMediaPlayerAppContext } from '@polyvharmony/media-player-sdk';
+let PLVLinkMicBitRate = PLVLinkMicBitRate_1 = class PLVLinkMicBitRate {
+    constructor(index, name) {
+        this.index = index;
+        this.name = name;
+    }
+    get nameString() {
+        if (typeof this.name === 'string') {
+            return this.name;
+        }
+        else {
+            return PLVMediaPlayerAppContext.getString(this.name);
+        }
+    }
+};
+PLVLinkMicBitRate.STANDARD = new PLVLinkMicBitRate_1(0, { "id": -1, "type": 10003, params: ['app.string.plv_streamer_bit_rate_standard'], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+PLVLinkMicBitRate.HIGH = new PLVLinkMicBitRate_1(1, { "id": -1, "type": 10003, params: ['app.string.plv_streamer_bit_rate_high'], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+PLVLinkMicBitRate.SUPER = new PLVLinkMicBitRate_1(2, { "id": -1, "type": 10003, params: ['app.string.plv_streamer_bit_rate_super'], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+PLVLinkMicBitRate.SUPER_HIGH = new PLVLinkMicBitRate_1(3, { "id": -1, "type": 10003, params: ['app.string.plv_streamer_bit_rate_super_high'], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+PLVLinkMicBitRate = PLVLinkMicBitRate_1 = __decorate([
+    MixinToRaw
+], PLVLinkMicBitRate);
+export { PLVLinkMicBitRate };

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

@@ -0,0 +1,16 @@
+import { PLVLinkMicBitRate } from './PLVLinkMicBitRate';
+export declare class PLVLinkMicBitRateEncodeParam {
+    readonly bitRate: PLVLinkMicBitRate;
+    readonly videoFps: number;
+    readonly videoGop: number;
+    readonly videoWidth: number;
+    readonly videoHeight: number;
+    readonly videoBitrate: number;
+    readonly screenFps: number;
+    readonly screenGop: number;
+    readonly screenWidth: number;
+    readonly screenHeight: number;
+    readonly screenBitrate: number;
+    constructor(bitRate: PLVLinkMicBitRate, d130: number, e130: number, videoWidth: number, videoHeight: number, videoBitrate: number, f130: number, g130: number, screenWidth: number, screenHeight: number, h130: number);
+}
+export declare const DEFAULT_BITRATE_ENCODE_PARAM_TABLE: PLVLinkMicBitRateEncodeParam[];

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

@@ -0,0 +1,34 @@
+import { PLVLinkMicBitRate } from './PLVLinkMicBitRate';
+export class PLVLinkMicBitRateEncodeParam {
+    constructor(bitRate, d130, e130, videoWidth, videoHeight, videoBitrate, f130, g130, screenWidth, screenHeight, h130) {
+        this.bitRate = bitRate;
+        this.videoFps = d130;
+        this.videoGop = e130;
+        this.videoWidth = videoWidth;
+        this.videoHeight = videoHeight;
+        this.videoBitrate = videoBitrate;
+        this.screenFps = f130;
+        this.screenGop = g130;
+        this.screenWidth = screenWidth;
+        this.screenHeight = screenHeight;
+        this.screenBitrate = h130;
+    }
+}
+export const DEFAULT_BITRATE_ENCODE_PARAM_TABLE = [
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.STANDARD, 15, 2, 320, 180, 400, 15, 2, 320, 180, 400),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.STANDARD, 30, 2, 320, 180, 600, 30, 2, 320, 180, 600),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.STANDARD, 15, 2, 240, 180, 250, 15, 2, 240, 180, 250),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.STANDARD, 30, 2, 240, 180, 380, 30, 2, 240, 180, 380),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.HIGH, 15, 2, 640, 360, 900, 15, 2, 640, 360, 900),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.HIGH, 30, 2, 640, 360, 1200, 30, 2, 640, 360, 1200),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.HIGH, 15, 2, 480, 360, 640, 15, 2, 480, 360, 640),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.HIGH, 30, 2, 480, 360, 980, 30, 2, 480, 360, 980),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER, 15, 2, 1280, 720, 2260, 15, 2, 1280, 720, 2260),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER, 30, 2, 1280, 720, 3420, 30, 2, 1280, 720, 3420),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER, 15, 2, 960, 720, 1820, 15, 2, 960, 720, 1820),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER, 30, 2, 960, 720, 2760, 30, 2, 960, 720, 2760),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER_HIGH, 15, 2, 1920, 1080, 4160, 15, 2, 1920, 1080, 4160),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER_HIGH, 30, 2, 1920, 1080, 6300, 30, 2, 1920, 1080, 6300),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER_HIGH, 15, 2, 1440, 1080, 3620, 15, 2, 1440, 1080, 3620),
+    new PLVLinkMicBitRateEncodeParam(PLVLinkMicBitRate.SUPER_HIGH, 30, 2, 1440, 1080, 5520, 30, 2, 1440, 1080, 5520),
+];

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

@@ -0,0 +1,12 @@
+export declare class PLVLinkMicCameraFacing {
+    private constructor();
+    /**
+     * 前置摄像头
+     */
+    static FRONT: PLVLinkMicCameraFacing;
+    /**
+     * 后置摄像头
+     */
+    static BACK: PLVLinkMicCameraFacing;
+    switchNext(): PLVLinkMicCameraFacing;
+}

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

@@ -0,0 +1,14 @@
+export class PLVLinkMicCameraFacing {
+    constructor() {
+    }
+    switchNext() {
+        if (this === PLVLinkMicCameraFacing.FRONT) {
+            return PLVLinkMicCameraFacing.BACK;
+        }
+        else {
+            return PLVLinkMicCameraFacing.FRONT;
+        }
+    }
+}
+PLVLinkMicCameraFacing.FRONT = new PLVLinkMicCameraFacing();
+PLVLinkMicCameraFacing.BACK = new PLVLinkMicCameraFacing();

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

@@ -0,0 +1,47 @@
+export declare class PLVLinkMicChannelStatus {
+    master?: string | null;
+    microphoneStatus?: string | null;
+    type?: string | null;
+    joinList?: JoinList[] | null;
+    waitList?: WaitList[] | null;
+}
+declare class JoinList {
+    clientIp?: string | null;
+    nick?: string | null;
+    pic?: string | null;
+    roomId?: string | null;
+    sessionId?: string | null;
+    status?: string | null;
+    uid?: string | null;
+    userId?: string | null;
+    userType?: string | null;
+    classStatus?: ClassStatus | null;
+    loginId?: string | null;
+    actor?: string | null;
+    mute?: boolean | null;
+    pos?: number | null;
+    cupNum?: number | null;
+}
+declare class WaitList {
+    actor?: string | null;
+    loginId?: string | null;
+    clientIp?: string | null;
+    nick?: string | null;
+    pic?: string | null;
+    roomId?: string | null;
+    sessionId?: string | null;
+    status?: string | null;
+    uid?: string | null;
+    userId?: string | null;
+    userType?: string | null;
+    cupNum?: number | null;
+}
+declare class ClassStatus {
+    groupLeader?: number | null;
+    banned?: number | null;
+    paint?: number | null;
+    speaker?: number | null;
+    voice?: number | null;
+    audio?: number | null;
+}
+export {};

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

@@ -0,0 +1,8 @@
+export class PLVLinkMicChannelStatus {
+}
+class JoinList {
+}
+class WaitList {
+}
+class ClassStatus {
+}