@rongcloud/plugin-rtc 5.5.4-alpha.1 → 5.5.4

package/dist/core/codec/interface.d.ts

@@ -0,0 +1,168 @@
+/**
+ * 设置 RTC 人员 inner、outer 数据
+ */
+export interface IRTCUserData {
+    [key: string]: string;
+}
+export interface IRtcTokenData {
+    rtcToken: string;
+}
+/**
+ * 加入 RTC 房间的用户信息
+ */
+export interface IRTCJoinedInfo {
+    /**
+     * 设备 ID
+     */
+    deviceId: string;
+    /**
+     * RTC 房间 ID
+     */
+    roomId: string;
+    /**
+     * 加入的时间戳
+     */
+    joinTime: number;
+}
+export interface IRTCRoomInfo {
+    roomId: string;
+    roomData: unknown[];
+    userCount: number;
+    list: unknown[];
+}
+export interface IServerRTCRoomEntry {
+    key: string;
+    value: string;
+    status: number;
+    timestamp: number;
+    uid: string;
+}
+export interface IRTCUsers {
+    users: {
+        [userId: string]: {
+            /**
+             * 发布的资源数据，是一个 JSON 字符串，解析后为发布的资源列表
+             */
+            uris?: string;
+            /**
+             * 加房间的身份标识，保存主房间 roomId
+             */
+            extra?: string;
+        };
+    };
+}
+export interface IJoinRTCRoomData extends IRTCUsers {
+    token: string;
+    sessionId: string;
+    roomInfo: {
+        key: string;
+        value: string;
+    }[];
+    kvEntries: IServerRTCRoomEntry[];
+    offlineKickTime: number;
+}
+export interface IReqRoomPKOptions {
+    /**
+     * 当前房间 ID
+     */
+    roomId: string;
+    /**
+     * 被邀请房间 ID
+     */
+    invitedRoomId: string;
+    /**
+     * 被邀请用户 ID
+     */
+    invitedUserId: string;
+    /**
+     * 本次邀请超时时间
+     */
+    inviteTimeout: number;
+    /**
+     * 本次邀请额外信息
+     */
+    inviteInfo: string;
+    /**
+     * 本次邀请唯一 ID
+     */
+    inviteSessionId: string;
+}
+export interface ICancelRoomPKOptions {
+    /**
+     * 当前房间 ID
+     */
+    roomId: string;
+    /**
+     * 被邀请房间 ID
+     */
+    invitedRoomId: string;
+    /**
+     * 被邀请用户 ID
+     */
+    invitedUserId: string;
+    /**
+     * 本次邀请额外信息
+     */
+    inviteInfo: string;
+    /**
+     * 本次邀请唯一 ID
+     */
+    inviteSessionId: string;
+}
+export interface IResRoomPKOptions {
+    /**
+     * 当前房间 ID
+     */
+    roomId: string;
+    /**
+     * 邀请者 ID
+     */
+    inviteUserId: string;
+    /**
+     * 邀请者房间 ID
+     */
+    inviteRoomId: string;
+    /**
+     * 邀请的 session ID
+     */
+    inviteSessionId: string;
+    /**
+     * 需要转发的信息
+     */
+    content: string;
+    /**
+     * 同意邀请时要设置的 key, 放在room级别的k和v,新加入房间的能拉取到
+     */
+    key: string;
+    /**
+     * 同意邀请时要设置的 value, 放在room级别的k和v,新加入房间的能拉取到
+     */
+    value: string;
+    /**
+     * 是否同意邀请
+     */
+    agree: boolean;
+}
+export interface IEndRoomPKOptions {
+    /**
+     * 当前房间 ID
+     */
+    roomId: string;
+    /**
+     * 需要结束的连麦房间 ID
+     */
+    endRoomId: string;
+    /**
+     * 需要结束连麦的 sessionID
+     */
+    sessionId: string;
+    /**
+     * 结束连麦的信息
+     */
+    content: string;
+    /**
+     * 需要删除连麦的信息的 keys
+     */
+    keys: string[];
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/core/codec/proto.d.ts

@@ -0,0 +1,94 @@
+/**
+ * signal 服务 RTC 业务的接口定义
+ */
+export declare const RTC_API: {
+    rtcRJoin_data: string;
+    rtcRExit: string;
+    rtcRInfo: string;
+    rtcUData: string;
+    rtcUDel: string;
+    rtcSetData: string;
+    /** 全量资源 URI 变更接口 */
+    userSetData: string;
+    rtcQryData: string;
+    rtcDelData: string;
+    rtcToken: string;
+    rtcUserState: string;
+    rtcUList: string;
+    /** RTC 直播观众加房间 */
+    viewerJoinR: string;
+    /** RTC 直播观众退出房间 */
+    viewerExitR: string;
+    /** RTC 观众端 kv 通知拉取 (kv 为主播加入/退出人员列表、发布/取消发布的资源) */
+    rtcPullKv: string;
+    /** RTC 直播身份切换 */
+    rtcIdentityChange: string;
+    /** 直播连麦邀请 */
+    rtcInvite: string;
+    /** 直播连麦取消邀请 */
+    rtcCancelInvite: string;
+    /** 直播连麦邀请响应 */
+    rtcInviteAnswer: string;
+    /** 结束直播连麦邀请 */
+    rtcEndInvite: string;
+    /** RTC 查询用户信息（是否在房间内） */
+    rtcQueryJoined: string;
+};
+export declare enum RTCPB {
+    RtcInput = "RtcInput",
+    RtcUserListOutput = "RtcUserListOutput",
+    SetUserStatusInput = "SetUserStatusInput",
+    RtcSetDataInput = "RtcSetDataInput",
+    RtcUserSetDataInput = "RtcUserSetDataInput",
+    RtcDataInput = "RtcDataInput",
+    RtcSetOutDataInput = "RtcSetOutDataInput",
+    MCFollowInput = "MCFollowInput",
+    RtcTokenOutput = "RtcTokenOutput",
+    RtcQryOutput = "RtcQryOutput",
+    RtcQryUserOutDataInput = "RtcQryUserOutDataInput",
+    RtcUserOutDataOutput = "RtcUserOutDataOutput",
+    RtcQueryListInput = "RtcQueryListInput",
+    RtcRoomInfoOutput = "RtcRoomInfoOutput",
+    RtcValueInfo = "RtcValueInfo",
+    RtcKeyDeleteInput = "RtcKeyDeleteInput",
+    RtcNotifyMsg = "RtcNotifyMsg",
+    RtcPullKV = "RtcPullKV",
+    RtcKVOutput = "RtcKVOutput",
+    RtcQueryUserJoinedInput = "RtcQueryUserJoinedInput",
+    RtcQueryUserJoinedOutput = "RtcQueryUserJoinedOutput",
+    RtcViewerJoinedOutput = "RtcViewerJoinedOutput",
+    RtcInviteInput = "RtcInviteInput",
+    RtcCancelInviteInput = "RtcCancelInviteInput",
+    RtcInviteAnswerInput = "RtcInviteAnswerInput",
+    RtcEndInviteInput = "RtcEndInviteInput"
+}
+export declare const keymaps: {
+    readonly RtcInput: readonly ["roomType", "broadcastType", "extraInnerData", "needSysChatroom", "identityChangeType", "joinType", "innerDatas", "outerDatas"];
+    readonly RtcUserListOutput: readonly ["users", "token", "sessionId", "roomInfo"];
+    readonly SetUserStatusInput: readonly ["status"];
+    readonly RtcSetDataInput: readonly ["interior", "target", "key", "value", "objectName", "content"];
+    readonly RtcUserSetDataInput: readonly ["valueInfo", "objectName", "content"];
+    readonly RtcDataInput: readonly ["interior", "target", "key", "objectName", "content"];
+    readonly RtcSetOutDataInput: readonly ["target", "valueInfo", "objectName", "content"];
+    readonly MCFollowInput: readonly ["state"];
+    readonly RtcTokenOutput: readonly ["rtcToken"];
+    readonly RtcQryOutput: readonly ["outInfo"];
+    readonly RtcQryUserOutDataInput: readonly ["userId"];
+    readonly RtcUserOutDataOutput: readonly ["user"];
+    readonly RtcQueryListInput: readonly ["order"];
+    readonly RtcRoomInfoOutput: readonly ["roomId", "roomData", "userCount", "list"];
+    readonly RtcValueInfo: readonly ["key", "value"];
+    readonly RtcKeyDeleteInput: readonly ["key"];
+    readonly RtcNotifyMsg: readonly ["type", "time", "roomId"];
+    readonly RtcPullKV: readonly ["timestamp", "roomId"];
+    readonly RtcKVOutput: readonly ["entries", "bFullUpdate", "syncTime"];
+    readonly RtcQueryUserJoinedInput: readonly ["userId"];
+    readonly RtcQueryUserJoinedOutput: readonly ["info"];
+    readonly RtcInviteInput: readonly ["invitedUserId", "timeoutTime", "invitedRoomId", "inviteInfo", "inviteSessionId"];
+    readonly RtcCancelInviteInput: readonly ["invitedUserId", "invitedRoomId", "inviteInfo", "inviteSessionId"];
+    readonly RtcInviteAnswerInput: readonly ["inviteUserId", "answerCode", "inviteRoomId", "inviteSessionId", "content", "key", "value"];
+    readonly RtcEndInviteInput: readonly ["inviteRoomId", "inviteSessionId", "inviteContent", "inviteRoomKeys"];
+};
+export declare type RTCKeyMaps = typeof keymaps;
+export declare const desc: string;
+//# sourceMappingURL=proto.d.ts.map

package/dist/core/codec/rtc-helper.d.ts

@@ -0,0 +1,17 @@
+import { AbsCodec } from '@rongcloud/engine';
+import { RTCMode } from '../enums/RTCMode';
+import { RTCJoinType } from '../enums/RTCJoinType';
+import { RTCKeyMaps } from './proto';
+import { IRTCUserData, IJoinRTCRoomData } from './interface';
+export declare const encodeRtcInput: (codec: AbsCodec<RTCKeyMaps>, roomType: RTCMode, broadcastType?: number, joinType?: RTCJoinType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData) => ArrayBuffer | {
+    roomType?: any;
+    broadcastType?: any;
+    extraInnerData?: any;
+    needSysChatroom?: any;
+    identityChangeType?: any;
+    joinType?: any;
+    innerDatas?: any;
+    outerDatas?: any;
+};
+export declare const decodeRtcUserListOutput: (codec: AbsCodec<RTCKeyMaps>, buffer: Uint8Array | string) => IJoinRTCRoomData;
+//# sourceMappingURL=rtc-helper.d.ts.map

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

@@ -0,0 +1,55 @@
+import { RCCommandKind } from '../enums/RCCommandKind';
+import { RCLinkedListPoint } from '../enums/RCLinkedListPoint';
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { ISubscribeAttr } from '../interfaces';
+import { Store } from '../Store';
+import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
+import { BaseCommand } from './BaseCommand';
+export declare type taskCompletedParams = {
+    code: RCRTCCode;
+    subscribe?: ISubscribeAttr[];
+    unsubscribe?: ISubscribeAttr[];
+    failedList?: ISubscribeAttr[];
+};
+export declare type AsyncCommandCallback = {
+    onTaskCompleted: (content: taskCompletedParams) => void;
+};
+export declare abstract class AsyncCommand<RES, STORE = Store> extends BaseCommand<RES> {
+    protected state: RCLinkedListPoint;
+    constructor(state?: RCLinkedListPoint);
+    get kind(): RCCommandKind;
+    /**
+     * `public setState（状态：RCLinkedListPoint）：void`
+     *
+     * 该函数是公共的，它被称为 setState，它接受一个称为 state 的参数，它什么也不返回
+     * @param {RCLinkedListPoint} state - 链表的状态。
+     */
+    setState(state: RCLinkedListPoint): void;
+    static AsyncSubscribeTasks: (RCRemoteTrack | ISubscribeAttr)[];
+    static AsyncUnsubscribeTasks: (RCRemoteTrack | ISubscribeAttr)[];
+    static AsyncUpdateSubscribeTasks: (RCRemoteTrack | ISubscribeAttr)[];
+    /**
+     * 该功能用于向房间发送消息，任务完成时向房间发送消息
+     * @param {Store} store - 店铺
+     * @param {RCRTCCode} code - 任务的状态码，即任务的状态码。
+     * @param {ISubscribeAttr[]} tracks - 要订阅的Tracks
+     */
+    protected pickoutSubscribed(subscribedTracks: ISubscribeAttr[], originTracks: ISubscribeAttr[]): {
+        subscribe: ISubscribeAttr[];
+        unsubscribe: ISubscribeAttr[];
+    };
+    private calcSubscribeList;
+    /**
+     * 它需要一个轨道数组并返回一个轨道数组。
+     * @param {(RCRemoteTrack | ISubscribeAttr)[]} tracks - (RCRemoteTrack | ISubscribeAttr)[]
+     * @returns 具有 track 属性的对象数组。
+     */
+    protected formateTrack(tracks: (RCRemoteTrack | ISubscribeAttr)[]): ISubscribeAttr[];
+    /**
+     * 它检查 Track 是否已经在订阅列表中。
+     * @param {ISubscribeAttr} track - ISubscribeAttr：要添加到列表中的 track
+     * @param {ISubscribeAttr[]} tracks - 需要订阅的 track 数组
+     */
+    private trackInSubscribeList;
+}
+//# sourceMappingURL=AsyncCommand.d.ts.map

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

@@ -0,0 +1,28 @@
+import { RCLinkedListPoint } from '../enums/RCLinkedListPoint';
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { ISubscribeAttr } from '../interfaces';
+import { Invoker } from '../Invoker';
+import { Store } from '../Store';
+import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
+import { AsyncCommand, AsyncCommandCallback } from './AsyncCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
+export declare class AsyncSubscribeCommand extends AsyncCommand<{
+    code: RCRTCCode;
+    failedList?: ISubscribeAttr[];
+}> {
+    private readonly tracks;
+    private subhook;
+    private callbacks;
+    constructor(tracks: (RCRemoteTrack | ISubscribeAttr)[], subhook: Subscribehook, callbacks: AsyncCommandCallback, state?: RCLinkedListPoint);
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
+    /**
+     * 如果当前节点的状态为 MIDDLE，则返回 store 的订阅属性列表。否则，返回存储的订阅属性列表
+     * @param {Store} store
+     * @returns ISubscribeAttr 对象的数组。
+     */
+    private getSubscribedList;
+}
+//# sourceMappingURL=AsyncSubscribeCommand.d.ts.map

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

@@ -0,0 +1,28 @@
+import { RCLinkedListPoint } from '../enums/RCLinkedListPoint';
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { ISubscribeAttr } from '../interfaces';
+import { Invoker } from '../Invoker';
+import { Store } from '../Store';
+import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
+import { AsyncCommand, AsyncCommandCallback } from './AsyncCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
+export declare class AsyncUnsubscribeCommand extends AsyncCommand<{
+    code: RCRTCCode;
+    failedList?: ISubscribeAttr[];
+}> {
+    private tracks;
+    private subhook;
+    private callbacks;
+    constructor(tracks: RCRemoteTrack[], subhook: Subscribehook, callbacks: AsyncCommandCallback, state?: RCLinkedListPoint);
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
+    /**
+     * 如果当前节点的状态为 MIDDLE，则返回 store 的订阅属性列表。否则，返回存储的订阅属性列表
+     * @param {Store} store
+     * @returns ISubscribeAttr 对象的数组。
+     */
+    private getSubscribedList;
+}
+//# sourceMappingURL=AsyncUnsubscribeCommand.d.ts.map

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

@@ -0,0 +1,25 @@
+import { RCLinkedListPoint } from '../enums/RCLinkedListPoint';
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { ISubscribeAttr } from '../interfaces';
+import { Invoker } from '../Invoker';
+import { Store } from '../Store';
+import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
+import { AsyncCommand, AsyncCommandCallback } from './AsyncCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
+/**
+ * 更新订阅关系，为强制更新订阅关系，传入的 Tracks 都会被订阅
+ */
+export declare class AsyncUpdateSubscribeListCommand extends AsyncCommand<{
+    code: RCRTCCode;
+    failedList?: ISubscribeAttr[];
+}> {
+    private readonly tracks;
+    private subhook;
+    private callbacks;
+    constructor(tracks: (RCRemoteTrack | ISubscribeAttr)[], subhook: Subscribehook, callbacks: AsyncCommandCallback, state?: RCLinkedListPoint);
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
+}
+//# sourceMappingURL=AsyncUpdateSubscribeListCommand.d.ts.map

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

@@ -0,0 +1,31 @@
+import { RCCommandKind } from '../enums/RCCommandKind';
+import { BaseInvoker } from '../Invoker';
+import { Store } from '../Store';
+export declare enum CommandPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
+export declare enum CommandCode {
+    Destroy = 40400
+}
+/**
+ * 命令基类
+ */
+export declare abstract class BaseCommand<RES, STORE = Store> {
+    /**
+     * 执行指令
+     * @param store
+     */
+    abstract execute(store: STORE, invoker: BaseInvoker<STORE>): Promise<RES>;
+    /**
+     * 获取指令优先级，必要时可 override 此函数
+     */
+    get priority(): CommandPriority;
+    /**
+     * 它返回命令的种类。
+     * @returns 命令的种类。
+     */
+    get kind(): RCCommandKind;
+}
+//# 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,31 @@
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { BaseCommand } from './BaseCommand';
+import { Store } from '../Store';
+import { ErrorCode } from '@rongcloud/engine';
+import { RCLivingType } from '../enums/RCLivingType';
+import { Invoker } from '../Invoker';
+import { RCCommandKind } from '../enums/RCCommandKind';
+import { RTCMode } from '../enums/RTCMode';
+import { RTCJoinType } from '../enums/RTCJoinType';
+import { IJoinRTCRoomData, IRTCUserData } from '../codec/interface';
+/**
+ * 资源发布命令
+ */
+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);
+    get kind(): RCCommandKind;
+    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,32 @@
+import { RCCommandKind } from '../enums/RCCommandKind';
+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);
+    get kind(): RCCommandKind;
+    /**
+   * 结束跨房间连麦
+   * @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,18 @@
+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;
+    /**
+     * 接收 signal 扩散状态变更的结果
+     */
+    private readonly _recvSignalResultFn;
+    constructor(localTrack: RCLocalTrack, 
+    /**
+     * 接收 signal 扩散状态变更的结果
+     */
+    _recvSignalResultFn: Function);
+    execute(store: Store, invoker: Invoker): Promise<void>;
+}
+//# sourceMappingURL=LocalTrackMuteCommand.d.ts.map

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

@@ -0,0 +1,18 @@
+import { RCRTCCode } from '../enums/RCRTCCode';
+import { Invoker } from '../Invoker';
+import { IMCUConfig, ISetEnableCDN } from '../service';
+import { Store } from '../Store';
+import { BaseCommand } from './BaseCommand';
+export declare class MCUConfigFlushCommand extends BaseCommand<{
+    code: RCRTCCode;
+    res?: any;
+}> {
+    private data;
+    private cdnValues;
+    constructor(data: IMCUConfig | ISetEnableCDN, cdnValues: IMCUConfig);
+    execute(store: Store, invoker: Invoker): Promise<{
+        code: RCRTCCode;
+        res?: any;
+    }>;
+}
+//# sourceMappingURL=MCUConfigFlushCommand.d.ts.map

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

@@ -0,0 +1,13 @@
+import { Invoker } from '../Invoker';
+import { Store } from '../Store';
+import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
+import { BaseCommand } from './BaseCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
+export declare class OnRemoteUserUnpubCommand extends BaseCommand<void> {
+    private subhook;
+    private tracks;
+    private onTrackUnpublish;
+    constructor(subhook: Subscribehook, tracks: RCRemoteTrack[], onTrackUnpublish: (tracks: RCRemoteTrack[]) => void);
+    execute(store: Store, invoker: Invoker): Promise<void>;
+}
+//# sourceMappingURL=OnRemoteUserUnpubCommand.d.ts.map

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

@@ -0,0 +1,38 @@
+import { RCLivingType } from '../enums/RCLivingType';
+import { Invoker } from '../Invoker';
+import { Store } from '../Store';
+import { RCRemoteAudioTrack, RCRemoteTrack, RCRemoteVideoTrack } from '../tracks/RCRemoteTrack';
+import { BaseCommand, CommandPriority } from './BaseCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
+import { IJoinRTCRoomData } from '../codec/interface';
+export declare type ReconnectedCommandCallback = {
+    onPeerClosed: () => void;
+    onUserJoin: (userIds: string[]) => void;
+    onUserLeave: (userIds: string[]) => void;
+    onTrackPublish: (tracks: RCRemoteTrack[]) => void;
+    onTrackUnpublish: (tracks: RCRemoteTrack[]) => void;
+    onAudioMuteChange: (track: RCRemoteAudioTrack) => void;
+    onVideoMuteChange: (track: RCRemoteVideoTrack) => void;
+    onCDNEnableChange: (bool: boolean) => void;
+};
+export declare class OnSignalReconnectedCommand extends BaseCommand<{
+    data: IJoinRTCRoomData | undefined;
+} | void> {
+    private subhook;
+    private callbacks;
+    private livingType?;
+    constructor(subhook: Subscribehook, callbacks: ReconnectedCommandCallback, livingType?: RCLivingType | undefined);
+    /**
+     * @override
+     */
+    get priority(): CommandPriority;
+    execute(store: Store, invoker: Invoker): Promise<{
+        data: IJoinRTCRoomData | undefined;
+    } | void>;
+    /**
+     * 主播端断线重连后，需更新内存中的 CDN 数据
+     * 判断房间内 CDN 状态是否和内存数据一致，不一致时需通知到客户端
+     */
+    private executeInLivingRoom;
+}
+//# sourceMappingURL=OnSignalReconnectedCommand.d.ts.map