@rongcloud/plugin-rtc 5.4.2 → 5.4.4-alpha.2

package/dist/async-task-queue.d.ts

@@ -0,0 +1,9 @@
+export declare type AsyncTask<T = void> = () => Promise<T>;
+/**
+ * 将异步任务推送到异步队列，队列内任务先进先出，依次执行，执行完成后通过
+ * Promise.resolve 返回执行结果
+ * @param task 传参不能是 `async () => {}` 所定义的异步函数，
+ * 只能使用明确的 `() => Promise<T> | T` 形式，避免转义时微任务被提前执行
+ */
+export declare const push: <T>(task: AsyncTask<T>, name?: string) => Promise<T>;
+//# sourceMappingURL=async-task-queue.d.ts.map

package/dist/core/Invoker.d.ts

@@ -0,0 +1,46 @@
+import { RTCMode, RTCPluginContext } from '@rongcloud/engine';
+import { BaseCommand } from './command/BaseCommand';
+import { RCRTCCode } from './enums/RCRTCCode';
+import PolarisReporter from './PolarisReporter';
+import { RCMediaService } from './service';
+import { ReadableStore, Store } from './Store';
+import RCRTCPeerCManager from './webrtc/RCRTCPeerCManager';
+export declare class BaseInvoker<STORE> {
+    /**
+     * 内存数据管理实例
+     */
+    protected readonly _store: STORE;
+    /**
+     * 命令终止时返回的错误码定义
+     */
+    private abortCode;
+    constructor(
+    /**
+     * 内存数据管理实例
+     */
+    _store: STORE, 
+    /**
+     * 命令终止时返回的错误码定义
+     */
+    abortCode: RCRTCCode);
+    private _queue;
+    private _busy;
+    private _next;
+    private _execute;
+    push<R>(command: BaseCommand<R, STORE>): Promise<R>;
+    private _isDestroyed;
+    isDestroyed(): boolean;
+    destroy(): void;
+}
+/**
+ * 房间任务队列管理
+ */
+export declare class Invoker extends BaseInvoker<Store> {
+    constructor(context: RTCPluginContext, service: RCMediaService, peerMrg: RCRTCPeerCManager, roomId: string, crtUserId: string, mode: RTCMode, reporter: PolarisReporter, isUpgrade?: boolean, isMainRoom?: boolean);
+    /**
+     * 获取 store 存储实例，返回值类型 `ReadableStore`，避免非 command 定义中修改内存
+     */
+    get store(): ReadableStore;
+    destroy(): void;
+}
+//# sourceMappingURL=Invoker.d.ts.map

package/dist/core/PolarisReporter.d.ts

@@ -0,0 +1,35 @@
+import { RTCPluginContext, IRuntime } from '@rongcloud/engine';
+import { IInnerRCRTCStateReport } from './interfaces';
+import RCAbstractRoom from './room/RCAbstractRoom';
+import RCAudienceLivingRoom from './room/RCAudienceLivingRoom';
+import { PolarisRole } from './enums/inner/PolarisRole';
+export default class PolarisReporter {
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _roomId;
+    private readonly _crtRTCRoom;
+    private readonly _userRole;
+    constructor(_context: RTCPluginContext, _runtime: IRuntime, _roomId: string, _crtRTCRoom: RCAbstractRoom | RCAudienceLivingRoom, _userRole?: PolarisRole);
+    private _send;
+    private _getClientID;
+    /**
+     * 小流需去掉 _tiny，小流 resourceId 为 userId_tag_mediaType_tiny
+     */
+    private _getRealResourceId;
+    /**
+     * 生成北极星上报的 trackId
+     * @param resourceId userId_11_1_tiny 改为 userId_11_tiny_video
+     */
+    private _getPolarisTrackId;
+    sendR3R4Data(data: IInnerRCRTCStateReport): Promise<boolean>;
+    /**
+     * 加入房间
+     */
+    sendR1(): void;
+    /**
+     * RTC 和 LIVE 发布、取消发布
+     * RTC 订阅、取消订阅
+     */
+    sendR2(action: string, status: string, trackIds: string[]): void;
+}
+//# sourceMappingURL=PolarisReporter.d.ts.map

package/dist/core/RCAudienceClient.d.ts

@@ -0,0 +1,89 @@
+import { IRuntime, RTCPluginContext } from '@rongcloud/engine';
+import { IRCRTCReportListener, IRCRTCTrackEventListener, IRCRTCInitOptions } from './interfaces';
+import { RCRemoteTrack } from './tracks/RCRemoteTrack';
+import { RCLivingType } from './enums/RCLivingType';
+import { RCRTCCode } from './enums/RCRTCCode';
+import { RCMediaType } from './enums/RCMediaType';
+/**
+ * 直播观众客户端
+ */
+export default class RCAudienceClient {
+    private readonly _context;
+    /**
+     * 是否使用多 peerConnection
+     */
+    private readonly _useMutilPeerC?;
+    private _pc;
+    private _service;
+    /**
+     * RTCToken
+     */
+    private _rtcToken;
+    /**
+     * 已订阅的资源信息
+     */
+    private _liveUrl;
+    /**
+     * 已订阅的远端流
+     */
+    private readonly _subTracks;
+    /**
+     * 客户端传入的数据上报事件
+     */
+    private _reportListener;
+    /**
+     * 使用的 peerConnection 对应 id
+     */
+    private _pcName;
+    /**
+     * peerConnection 管理类
+     */
+    private _peerCManager;
+    private readonly _clientSessionId;
+    constructor(_context: RTCPluginContext, runtime: IRuntime, _initOption: IRCRTCInitOptions, 
+    /**
+     * 是否使用多 peerConnection
+     */
+    _useMutilPeerC?: boolean | undefined);
+    private _getReqHeaders;
+    private _clearSubscribeInfo;
+    private _livingType;
+    private _mediaType;
+    private _subTiny;
+    private _fromRetry;
+    private _reTryExchange;
+    /**
+     * 直播观众订阅主播资源，直播观众端无需加入房间
+     * @param liveUrl 直播资源地址
+     * @param livingType 直播类型，有效值为音频、音视频
+     * @param mediaType 订阅资源类型，其有效值为 `RCMediaType` 的枚举值
+     * @param subTiny 当值为 `true` 时将订阅小流，否则订阅大流。默认值为 `false`
+     */
+    subscribe(liveUrl: string, livingType: RCLivingType, mediaType: RCMediaType, subTiny?: boolean): Promise<{
+        code: RCRTCCode;
+        tracks: RCRemoteTrack[];
+    }>;
+    private __subscribe;
+    /**
+     * 取消订阅主播资源
+     * @param liveUrl
+     */
+    unsubscribe(): Promise<{
+        code: RCRTCCode;
+    }>;
+    private __unsubscribe;
+    /**
+     * 注册房间数据监控
+     * @param listener
+     * @description 该方法暂仅支持 Chrome 浏览器
+     */
+    registerReportListener(listener: IRCRTCReportListener | null): void;
+    private _appListener;
+    /**
+     * 注册流事件监听，多次注册会导致后者覆盖前者，可以通过使用 `registerTrackEventListener(null)` 取消注册
+     * @param listener
+     */
+    registerTrackEventListener(listener: IRCRTCTrackEventListener | null): void;
+    private _onTrackReady;
+}
+//# sourceMappingURL=RCAudienceClient.d.ts.map

package/dist/core/RCMediaStreamCapture.d.ts

@@ -0,0 +1,124 @@
+import { RCRTCCode } from './enums/RCRTCCode';
+import { ICameraVideoProfile, ICreateLocalTrackOptions, IMicphoneAudioProfile, IScreenVideoProfile } from './interfaces';
+import { RCCameraVideoTrack, RCLocalAudioTrack, RCLocalFileTrack, RCLocalTrack, RCLocalVideoTrack, RCMicphoneAudioTrack, RCScreenAudioTrack, RCScreenVideoTrack } from './tracks/RCLocalTrack';
+import { RTCPluginContext } from '@rongcloud/engine';
+export default class RCMediaStreamCapture {
+    protected readonly _context: RTCPluginContext;
+    constructor(_context: RTCPluginContext);
+    private _isElectron;
+    private _getMediaStream;
+    /**
+     * 如果用户设置了音频约束为true，那么我们将音频约束设置为一个空对象，
+     * 然后我们将检查浏览器是否支持noiseSuppression、autoGainControl和echoCancellation约束，
+     * 如果支持，那么我们将设置音频约束为真
+     * @param {any} constraints - 约束参数与 getUserMedia 方法中的约束参数相同。
+     * @returns 返回值是约束对象。
+     */
+    private setConstraintsConfig;
+    /**
+     * 从麦克风中捕获音轨数据
+     * @param tag
+     * @param options
+     * @returns
+     */
+    createMicrophoneAudioTrack(tag?: string, options?: IMicphoneAudioProfile): Promise<{
+        code: RCRTCCode;
+        track?: RCMicphoneAudioTrack;
+    }>;
+    /**
+     * 由摄像头捕获视轨数据
+     * @param tag
+     * @param options
+     * @returns
+     */
+    createCameraVideoTrack(tag?: string, options?: ICameraVideoProfile): Promise<{
+        code: RCRTCCode;
+        track?: RCCameraVideoTrack;
+    }>;
+    /**
+     * 通过摄像头与麦克风采集音视频轨道数据
+     * @param tag
+     * @param options
+     * @returns
+     */
+    createMicrophoneAndCameraTracks(tag?: string, options?: {
+        audio?: IMicphoneAudioProfile;
+        video?: ICameraVideoProfile;
+    }): Promise<{
+        code: RCRTCCode;
+        tracks: RCLocalTrack[];
+    }>;
+    /**
+     * 创建屏幕共享视频流，默认分辨率 `1280 * 720`，帧率 `15`
+     * @param tag 屏幕共享视轨数据标识
+     * @param options
+     * @description
+     * 支持 Electron 平台下通过制定 `chromeMediaSourceId` 的方式获取屏幕共享视频。
+     * 参考：https://www.electronjs.org/docs/api/desktop-capturer
+     */
+    createScreenVideoTrack(tag?: string, options?: IScreenVideoProfile): Promise<{
+        code: RCRTCCode;
+        track?: RCScreenVideoTrack;
+    }>;
+    /**
+     * 创建带音频的屏幕共享资源
+     * @param tag 屏幕共享视轨数据标识
+     * @param options
+     * @description electron 中 mac 系统暂不支持屏幕共享采集声音
+     * @returns 在可以取到音频的情况下，tracks 中包含音轨和视轨；取不到音视频时 tracks 仅返回视轨
+     */
+    createScreenWithAudioTracks(tag?: string, options?: IScreenVideoProfile): Promise<{
+        code: RCRTCCode;
+        tracks?: (RCScreenVideoTrack | RCScreenAudioTrack)[];
+    }>;
+    private _createScreenTracks;
+    /**
+     * 创建 RCLocalAudioTrack 实例
+     * @param tag
+     * @param track
+     * @returns
+     */
+    createLocalAudioTrack(tag: string, track: MediaStreamTrack): Promise<{
+        code: RCRTCCode;
+        track?: RCLocalAudioTrack;
+    }>;
+    /**
+     * 创建 RCLocalVideoTrack 实例
+     * @param tag 视轨数据标识
+     * @param track MediaStreamTrack 实例
+     * @returns
+     */
+    createLocalVideoTrack(tag: string, track: MediaStreamTrack): Promise<{
+        code: RCRTCCode;
+        track?: RCLocalVideoTrack;
+    }>;
+    /**
+     * 根据本地或网络媒体文件资源创建 `RCLocalFileTrack` 实例
+     * @param tag 资源标识
+     * @param file 网络文件地址，或通过 <input type='file'> 获取到的 File 实例
+     * @param options 可用于指定 `withoutVideo` 与 `withoutAudio` 以剔除视轨与音轨
+     */
+    createLocalFileTracks(tag: string, file: string | File, options?: ICreateLocalTrackOptions): Promise<{
+        code: RCRTCCode;
+        tracks: RCLocalFileTrack[];
+    }>;
+    /**
+     * 根据 MediaStream 实例对象创建 RCLocalTrack 实例
+     * @param tag 轨道标识
+     * @param stream MediaStream 实例
+     * @param options 可用于指定 `withoutVideo` 与 `withoutAudio` 以剔除视轨与音轨
+     * @returns
+     */
+    createLocalTracks(tag: string, stream: MediaStream, options?: ICreateLocalTrackOptions): Promise<{
+        code: RCRTCCode;
+        tracks: RCLocalTrack[];
+    }>;
+    /**
+     * 它接受一个 MediaStream 和一个可选的选项对象并返回一个 MediaStreamTracks 数组
+     * @param {MediaStream} stream - MediaStream - 从中获取曲目的流。
+     * @param {ICreateLocalTrackOptions} [options] - ICreateLocalTrackOptions
+     * @returns 一组 MediaStreamTrack 对象。
+     */
+    static getTracksWithOptions(stream: MediaStream, options?: ICreateLocalTrackOptions): Array<MediaStreamTrack | undefined>;
+}
+//# sourceMappingURL=RCMediaStreamCapture.d.ts.map

package/dist/core/RCRTCClient.d.ts

@@ -0,0 +1,126 @@
+import { ErrorCode, IRuntime, RTCMode, RTCPluginContext, IRTCJoinedInfo, RTCJoinType, IRTCUserData } from '@rongcloud/engine';
+import RCLivingRoom from './room/RCLivingRoom';
+import RCRTCRoom from './room/RCRTCRoom';
+import RCAudienceClient from './RCAudienceClient';
+import { IJoinResCDNInfo, IRCRTCInitOptions } from './interfaces';
+import RCAbstractRoom from './room/RCAbstractRoom';
+import { RCRTCCode } from './enums/RCRTCCode';
+import { RCLivingType } from './enums/RCLivingType';
+import { RCRemoteTrack } from './tracks/RCRemoteTrack';
+import RCAudienceLivingRoom from './room/RCAudienceLivingRoom';
+import RCMediaStreamCapture from './RCMediaStreamCapture';
+/**
+ * RTC 业务客户端
+ * @public
+ */
+export default class RCRTCClient extends RCMediaStreamCapture {
+    protected readonly _context: RTCPluginContext;
+    private readonly _runtime;
+    private readonly _options;
+    private readonly _service;
+    constructor(_context: RTCPluginContext, _runtime: IRuntime, _options: IRCRTCInitOptions);
+    private _handleMessage;
+    /**
+     * 获取加入的连麦房间
+     */
+    private _getJoinedPKRoomList;
+    /**
+     * 获取当前用户 Id，若 IM 未连接，这返回 `''`
+     * @returns
+     */
+    getCurrentId(): string;
+    private _crtRoom;
+    /**
+     * 加入普通音视频房间
+     * @param roomId
+     * @param joinType 多端处理方式
+     * @param outerUserDatas 业务层设置人员属性
+     * @param useMutilPeerC 是否使用多 peerConnection 发布资源
+     * @param roomType 加入房间的类型 默认参数 RTCMode.RTC
+     */
+    joinRTCRoom(roomId: string, joinType?: RTCJoinType, outerUserDatas?: IRTCUserData, useMutilPeerC?: boolean, roomType?: RTCMode): Promise<{
+        room?: RCRTCRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+    }>;
+    /**
+     * 主播加入直播房间或观众上麦场景调用，观众上麦之前需先取消已订阅的直播间资源
+     * @param roomId 房间 Id
+     * @param livingType 直播间类型，`RCLivingType.AUDIO` 为音频直播，`RCLivingType.VIDEO` 为音视频直播
+     * @param joinType 多端处理方式，公有云暂不支持该字段
+     * @param outerUserDatas 业务层设置人员属性
+     */
+    joinLivingRoom(roomId: string, livingType: RCLivingType, joinType?: RTCJoinType, outerUserDatas?: IRTCUserData, useMutilPeerC?: boolean): Promise<{
+        room?: RCLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+        CDNEnable?: boolean;
+    }>;
+    private _audience;
+    /**
+     * 获取直播观众客户端
+     */
+    getAudienceClient(useMutilPeerC?: boolean): RCAudienceClient;
+    private _onIMStatusChange;
+    private _onIMDisconnect;
+    private _onIMUninit;
+    /**
+     * 退出并销毁当前房间实例，退出后该房间的所有方法将不可用
+     */
+    leaveRoom(room: RCAbstractRoom): Promise<{
+        code: RCRTCCode;
+    }>;
+    private _crtAudienceLivingRoom;
+    /**
+     * 观众加入直播房间
+     * @param roomId 房间 ID
+     * @param livingType 直播类型（音频直播 or 音视频直播）
+     */
+    joinLivingRoomAsAudience(roomId: string, livingType: RCLivingType, useMutilPeerC?: boolean): Promise<{
+        room?: RCAudienceLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        RTCTracks?: RCRemoteTrack[];
+        MCUTracks?: RCRemoteTrack[];
+        CDNUris?: IJoinResCDNInfo;
+    }>;
+    /**
+     * 观众退出并销毁当前房间实例，退出后该房间的所有方法将不可用
+     */
+    leaveLivingRoomAsAudience(room: RCAudienceLivingRoom): Promise<{
+        code: RCRTCCode;
+    }>;
+    /**
+     * 升级为主播房间
+     * @param room 观众房间实例
+     */
+    upgradeToAnchorRoom(room: RCAudienceLivingRoom): Promise<{
+        room?: RCLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+    }>;
+    /**
+     * 降级为观众房间
+     * @param room 主播房间实例
+     */
+    downgradeToAudienceRoom(room: RCLivingRoom): Promise<{
+        room?: RCAudienceLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        RTCTracks?: RCRemoteTrack[];
+        MCUTracks?: RCRemoteTrack[];
+        CDNUris?: IJoinResCDNInfo;
+    }>;
+    /**
+     * 获取在房间内用户信息
+     * @since version 5.2.1
+     */
+    getJoinedRoomInfo(): Promise<{
+        code: RCRTCCode | ErrorCode;
+        data?: IRTCJoinedInfo[];
+    }>;
+}
+//# sourceMappingURL=RCRTCClient.d.ts.map

package/dist/core/Store.d.ts

@@ -0,0 +1,80 @@
+import { IJoinRTCRoomData, RTCMode, RTCPluginContext } from '@rongcloud/engine';
+import { IPublishedResource, ISubscribeAttr, RoomData } from './interfaces';
+import PolarisReporter from './PolarisReporter';
+import { RCMediaService } from './service';
+import { ICDNUris } from './service/interface';
+import { RCLocalTrack } from './tracks/RCLocalTrack';
+import { RCRemoteAudioTrack, RCRemoteTrack, RCRemoteVideoTrack } from './tracks/RCRemoteTrack';
+import RCRTCPeerCManager from './webrtc/RCRTCPeerCManager';
+export declare const StoreEvent: {};
+export declare abstract class ReadableStore {
+    readonly context: RTCPluginContext;
+    readonly service: RCMediaService;
+    readonly peerMgr: RCRTCPeerCManager;
+    readonly roomId: string;
+    readonly crtUserId: string;
+    readonly roomMode: RTCMode;
+    readonly polarisReport: PolarisReporter;
+    readonly isUpgrade?: boolean | undefined;
+    readonly isMainRoom?: boolean | undefined;
+    /**
+     * 房间资源数据
+     */
+    protected _roomResources: RoomData;
+    /**
+     * 远端 track
+     */
+    protected _remoteTracks: {
+        [trackId: string]: RCRemoteAudioTrack | RCRemoteVideoTrack;
+    };
+    /**
+     * 已订阅参数
+     */
+    protected readonly _subscribedList: ISubscribeAttr[];
+    /**
+     * 与 MediaServer 交互需要的 token 信息
+     */
+    protected _token: string;
+    /**
+     * 每次加入房间后都会改变
+     */
+    protected _sessionId: string;
+    /**
+     * cdn_uris 信令扩散数据
+     */
+    protected _CDNUris: ICDNUris | null;
+    protected _CDNEnable: boolean;
+    protected _destroyed: boolean;
+    constructor(context: RTCPluginContext, service: RCMediaService, peerMgr: RCRTCPeerCManager, roomId: string, crtUserId: string, roomMode: RTCMode, polarisReport: PolarisReporter, isUpgrade?: boolean | undefined, isMainRoom?: boolean | undefined);
+    get useMutilPeerC(): boolean;
+    getResourcesByUserId(userId: string): IPublishedResource[] | undefined;
+    getRemoteTrack(trackId: string): RCRemoteTrack | undefined;
+    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
+    getRemoteTracks(): {
+        [trackId: string]: RCRemoteAudioTrack | RCRemoteVideoTrack;
+    };
+    getSessionId(): string;
+    getAllUserIds(): string[];
+    getRemoteUserIds(): string[];
+    getSubscribedList(): ISubscribeAttr[];
+    getPublishedResourceByTrackId(trackId: string): IPublishedResource | undefined;
+    getToken(): string;
+    getLocalTrack(trackId: string): RCLocalTrack | null;
+    getLocalTracks(): RCLocalTrack[];
+    getTrackState(trackId: string): 0 | 1;
+    getCDNEnable(): boolean;
+    getCDNUris(): ICDNUris | null;
+}
+export declare class Store extends ReadableStore {
+    private _initRemoteTracks;
+    initWithRoomData(data: IJoinRTCRoomData): void;
+    assignRoomData(data: RoomData): void;
+    setResourcesByUserId(userId: string, arr: IPublishedResource[]): void;
+    removeRemoteTrack(trackId: string): void;
+    removeResourcesByUserId(userId: string): void;
+    addRemoteTrack(track: RCRemoteTrack): void;
+    removeRemoteTracks(): void;
+    setCDNEnabel(bool: boolean): void;
+    setCDNUris(uris: ICDNUris | null): void;
+}
+//# sourceMappingURL=Store.d.ts.map

package/dist/core/command/BaseCommand.d.ts

@@ -0,0 +1,22 @@
+import { BaseInvoker } from '../Invoker';
+import { Store } from '../Store';
+export declare enum CommandPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
+/**
+ * 命令基类
+ */
+export declare abstract class BaseCommand<RES, STORE = Store> {
+    /**
+     * 执行指令
+     * @param store
+     */
+    abstract execute(store: STORE, invoker: BaseInvoker<STORE>): Promise<RES>;
+    /**
+     * 获取指令优先级，必要时可 override 此函数
+     */
+    get priority(): CommandPriority;
+}
+//# sourceMappingURL=BaseCommand.d.ts.map

package/dist/core/command/EnabelInnerCDNCommand.d.ts

@@ -0,0 +1,16 @@
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { Invoker } from '../Invoker';
+import { IMCUConfig } from '../service/mcu-interface';
+import { Store } from '../Store';
+import { BaseCommand } from './BaseCommand';
+export declare class EnableInnerCDNCommand extends BaseCommand<{
+    code: RCRTCCode;
+}> {
+    private cdnValues;
+    private enable;
+    constructor(cdnValues: IMCUConfig, enable: boolean);
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: RCRTCCode;
+    }>;
+}
+//# sourceMappingURL=EnabelInnerCDNCommand.d.ts.map

package/dist/core/command/ExchangeCommand.d.ts

@@ -0,0 +1,18 @@
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { Invoker } from '../Invoker';
+import { IExchangeReqBody, IExchangeResponse, IRTCReqHeader } from '../service';
+import { Store } from '../Store';
+import { BaseCommand } from './BaseCommand';
+export declare class ExchangeCommand extends BaseCommand<{
+    code: RCRTCCode;
+    data?: IExchangeResponse;
+}> {
+    private headers;
+    private reqBody;
+    constructor(headers: IRTCReqHeader, reqBody: IExchangeReqBody);
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: RCRTCCode;
+        data?: IExchangeResponse;
+    }>;
+}
+//# sourceMappingURL=ExchangeCommand.d.ts.map

package/dist/core/command/ExchangeWithPushOtherRoomCommand.d.ts

@@ -0,0 +1,22 @@
+import { Invoker } from '../Invoker';
+import { RCLivingPKHandler } from '../room/RCLivingPKHandler';
+import { IPushOtherRooms, IRTCReqHeader } from '../service/interface';
+import { Store } from '../Store';
+import { BaseCommand } from './BaseCommand';
+export declare type ExchangeHooksRes = {
+    headers: IRTCReqHeader;
+    pushOtherRooms: IPushOtherRooms[];
+};
+export declare type ExchangeHooks = (pcName: string) => ExchangeHooksRes;
+export declare class ExchangeWithPushOtherRoomCommand extends BaseCommand<void> {
+    private roomId;
+    private hooks;
+    private roomPKHandler?;
+    constructor(roomId: string, hooks: ExchangeHooks, roomPKHandler?: RCLivingPKHandler | undefined);
+    /**
+     * 携带 pushOtherRooms 与 mediaServer 重新交互
+     */
+    private _exchangeWithPushOtherRoom;
+    execute(store: Store, invoker: Invoker): Promise<void>;
+}
+//# sourceMappingURL=ExchangeWithPushOtherRoomCommand.d.ts.map

package/dist/core/command/JoinRoomCommand.d.ts

@@ -0,0 +1,26 @@
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { BaseCommand } from './BaseCommand';
+import { Store } from '../Store';
+import { ErrorCode, IJoinRTCRoomData, IRTCUserData, RTCJoinType, RTCMode } from '@rongcloud/engine';
+import { RCLivingType } from '../enums/RCLivingType';
+import { Invoker } from '../Invoker';
+/**
+ * 资源发布命令
+ */
+export declare class JoinRoomCommand extends BaseCommand<{
+    code: ErrorCode | RCRTCCode;
+    data?: IJoinRTCRoomData;
+}> {
+    private readonly roomId;
+    private readonly roomType;
+    private readonly joinType?;
+    private readonly livingType?;
+    private readonly innerUserDatas?;
+    private readonly outerUserDatas?;
+    constructor(roomId: string, roomType: RTCMode, joinType?: RTCJoinType | undefined, livingType?: RCLivingType | undefined, innerUserDatas?: IRTCUserData | undefined, outerUserDatas?: IRTCUserData | undefined);
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: ErrorCode | RCRTCCode;
+        data?: IJoinRTCRoomData;
+    }>;
+}
+//# sourceMappingURL=JoinRoomCommand.d.ts.map

package/dist/core/command/LeaveOtherRoomCommand.d.ts

@@ -0,0 +1,30 @@
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { IPKInfo } from '../interfaces';
+import { Invoker } from '../Invoker';
+import { RCLivingPKHandler } from '../room/RCLivingPKHandler';
+import RCLivingRoom from '../room/RCLivingRoom';
+import { Store } from '../Store';
+import { BaseCommand } from './BaseCommand';
+import { ExchangeHooks } from './ExchangeWithPushOtherRoomCommand';
+export declare class LeaveOtherRoomCommand extends BaseCommand<{
+    code: RCRTCCode;
+}> {
+    private pkHandler;
+    private room;
+    private _PKInfo;
+    private hooks;
+    private _joinedPKRooms;
+    private isQuitPK?;
+    constructor(pkHandler: RCLivingPKHandler, room: RCLivingRoom, _PKInfo: IPKInfo, hooks: ExchangeHooks, _joinedPKRooms: {
+        [roomId: string]: RCLivingRoom;
+    }, isQuitPK?: boolean | undefined);
+    /**
+   * 结束跨房间连麦
+   * @param roomId 需要结束连麦的房间 roomId
+   */
+    private quitRoomPK;
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: RCRTCCode;
+    }>;
+}
+//# sourceMappingURL=LeaveOtherRoomCommand.d.ts.map

package/dist/core/command/LocalTrackMuteCommand.d.ts

@@ -0,0 +1,10 @@
+import { Invoker } from '../Invoker';
+import { Store } from '../Store';
+import { RCLocalTrack } from '../tracks/RCLocalTrack';
+import { BaseCommand } from './BaseCommand';
+export declare class LocalTrackMuteCommand extends BaseCommand<void> {
+    private localTrack;
+    constructor(localTrack: RCLocalTrack);
+    execute(store: Store, invoker: Invoker): Promise<void>;
+}
+//# sourceMappingURL=LocalTrackMuteCommand.d.ts.map