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

package/dist/core/Invoker.d.ts

@@ -29,6 +29,14 @@ export declare class BaseInvoker<STORE> {
     private _execute;
     push<R>(command: BaseCommand<R, STORE>): Promise<R>;
     private _isDestroyed;
+    /**
+     * 查找出 RCCommandKind.AsyncCommand 类型的 Command，并将其从队列中删除
+     * 并使用最新的一次 Command 接管它的 resolve & reject
+     * @param resolve
+     * @param reject
+     * @returns 具有两个属性的对象，resolve 和 reject。
+     */
+    private commandOffset;
     isDestroyed(): boolean;
     destroy(): void;
 }

package/dist/core/Store.d.ts

@@ -30,7 +30,8 @@ export declare abstract class ReadableStore {
     /**
      * 已订阅参数
      */
-    protected readonly _subscribedList: ISubscribeAttr[];
+    protected _subscribedList: ISubscribeAttr[];
+    protected _collectSubscribeList: ISubscribeAttr[];
     /**
      * 与 MediaServer 交互需要的 token 信息
      */
@@ -57,6 +58,7 @@ export declare abstract class ReadableStore {
     getAllUserIds(): string[];
     getRemoteUserIds(): string[];
     getSubscribedList(): ISubscribeAttr[];
+    getCollectSubscribeList(): ISubscribeAttr[];
     getPublishedResourceByTrackId(trackId: string): IPublishedResource | undefined;
     getToken(): string;
     getLocalTrack(trackId: string): RCLocalTrack | null;
@@ -76,5 +78,7 @@ export declare class Store extends ReadableStore {
     removeRemoteTracks(): void;
     setCDNEnabel(bool: boolean): void;
     setCDNUris(uris: ICDNUris | null): void;
+    resetSubscribedList(subscribeList: ISubscribeAttr[]): void;
+    resetCollectSubscribeList(collectSubscribeList: ISubscribeAttr[]): void;
 }
 //# sourceMappingURL=Store.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

@@ -1,3 +1,4 @@
+import { RCCommandKind } from '../enums/RCCommandKind';
 import { BaseInvoker } from '../Invoker';
 import { Store } from '../Store';
 export declare enum CommandPriority {
@@ -5,6 +6,9 @@ export declare enum CommandPriority {
     NORMAL = 1,
     HIGH = 2
 }
+export declare enum CommandCode {
+    Destroy = 40400
+}
 /**
  * 命令基类
  */
@@ -18,5 +22,10 @@ export declare abstract class BaseCommand<RES, STORE = Store> {
      * 获取指令优先级，必要时可 override 此函数
      */
     get priority(): CommandPriority;
+    /**
+     * 它返回命令的种类。
+     * @returns 命令的种类。
+     */
+    get kind(): RCCommandKind;
 }
 //# sourceMappingURL=BaseCommand.d.ts.map

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

@@ -4,6 +4,7 @@ import { Store } from '../Store';
 import { ErrorCode, IJoinRTCRoomData, IRTCUserData, RTCJoinType, RTCMode } from '@rongcloud/engine';
 import { RCLivingType } from '../enums/RCLivingType';
 import { Invoker } from '../Invoker';
+import { RCCommandKind } from '../enums/RCCommandKind';
 /**
  * 资源发布命令
  */
@@ -18,6 +19,7 @@ export declare class JoinRoomCommand extends BaseCommand<{
     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;

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

@@ -1,3 +1,4 @@
+import { RCCommandKind } from '../enums/RCCommandKind';
 import { RCRTCCode } from '../enums/RCRTCCode';
 import { IPKInfo } from '../interfaces';
 import { Invoker } from '../Invoker';
@@ -18,6 +19,7 @@ export declare class LeaveOtherRoomCommand extends BaseCommand<{
     constructor(pkHandler: RCLivingPKHandler, room: RCLivingRoom, _PKInfo: IPKInfo, hooks: ExchangeHooks, _joinedPKRooms: {
         [roomId: string]: RCLivingRoom;
     }, isQuitPK?: boolean | undefined);
+    get kind(): RCCommandKind;
     /**
    * 结束跨房间连麦
    * @param roomId 需要结束连麦的房间 roomId

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

@@ -2,12 +2,12 @@ import { Invoker } from '../Invoker';
 import { Store } from '../Store';
 import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
 import { BaseCommand } from './BaseCommand';
-import { Subhook } from './UpdateSubListCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
 export declare class OnRemoteUserUnpubCommand extends BaseCommand<void> {
     private subhook;
     private tracks;
     private onTrackUnpublish;
-    constructor(subhook: Subhook, tracks: RCRemoteTrack[], onTrackUnpublish: (tracks: RCRemoteTrack[]) => void);
+    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

@@ -4,7 +4,7 @@ import { Invoker } from '../Invoker';
 import { Store } from '../Store';
 import { RCRemoteAudioTrack, RCRemoteTrack, RCRemoteVideoTrack } from '../tracks/RCRemoteTrack';
 import { BaseCommand, CommandPriority } from './BaseCommand';
-import { Subhook } from './UpdateSubListCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
 export declare type ReconnectedCommandCallback = {
     onPeerClosed: () => void;
     onUserJoin: (userIds: string[]) => void;
@@ -21,7 +21,7 @@ export declare class OnSignalReconnectedCommand extends BaseCommand<{
     private subhook;
     private callbacks;
     private livingType?;
-    constructor(subhook: Subhook, callbacks: ReconnectedCommandCallback, livingType?: RCLivingType | undefined);
+    constructor(subhook: Subscribehook, callbacks: ReconnectedCommandCallback, livingType?: RCLivingType | undefined);
     /**
      * @override
      */

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

@@ -5,7 +5,7 @@ import { ICDNUris } from '../service';
 import { Store } from '../Store';
 import { RCRemoteAudioTrack, RCRemoteTrack, RCRemoteVideoTrack } from '../tracks/RCRemoteTrack';
 import { BaseCommand, CommandPriority } from './BaseCommand';
-import { Subhook } from './UpdateSubListCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
 export declare type ResourceMsgContent = {
     /**
      * 旧版本兼容参数，当收到非 `RTCMessageName.TOTAL_CONTENT_RESOURCE` 时：
@@ -25,7 +25,7 @@ export declare class ParseRemoteResCommand extends BaseCommand<void> {
     private senderId;
     private subhook;
     private callback;
-    constructor(msgContent: ResourceMsgContent, messageType: RCRTCMessageType.PUBLISH | RCRTCMessageType.UNPUBLISH | RCRTCMessageType.MODIFY | RCRTCMessageType.TOTAL_CONTENT_RESOURCE, senderId: string, subhook: Subhook, callback: {
+    constructor(msgContent: ResourceMsgContent, messageType: RCRTCMessageType.PUBLISH | RCRTCMessageType.UNPUBLISH | RCRTCMessageType.MODIFY | RCRTCMessageType.TOTAL_CONTENT_RESOURCE, senderId: string, subhook: Subscribehook, callback: {
         onTrackPublish: (tracks: RCRemoteTrack[]) => void;
         onTrackUnublish: (tracks: RCRemoteTrack[]) => void;
         onAudioMute: (track: RCRemoteAudioTrack) => void;

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

@@ -2,7 +2,7 @@ import { RCRTCLiveRole } from '../enums/RCRTCLiveRole';
 import { Invoker } from '../Invoker';
 import { Store } from '../Store';
 import { BaseCommand, CommandPriority } from './BaseCommand';
-import { Subhook } from './UpdateSubListCommand';
+import { Subscribehook } from './UpdateSubscribeListCommand';
 declare type StateMsgContent = {
     users: {
         userId: string;
@@ -49,7 +49,7 @@ export interface IParseUserStateRes {
 export declare class ParseUserStateCommand extends BaseCommand<IParseUserStateRes> {
     private msgContent;
     private subhook;
-    constructor(msgContent: StateMsgContent, subhook: Subhook);
+    constructor(msgContent: StateMsgContent, subhook: Subscribehook);
     get priority(): CommandPriority;
     execute(store: Store, invoker: Invoker): Promise<IParseUserStateRes>;
 }

package/dist/core/command/{PubCommand.d.ts → PublishCommand.d.ts}

@@ -4,6 +4,7 @@ import { Store } from '../Store';
 import { RCLocalTrack } from '../tracks/RCLocalTrack';
 import { IPushOtherRooms, IRTCReqHeader } from '../service';
 import { Invoker } from '../Invoker';
+import { RCCommandKind } from '../enums/RCCommandKind';
 export declare type PubhookPeerItem = IMutilPeerC & {
     headers: IRTCReqHeader;
 };
@@ -15,10 +16,11 @@ export declare type Pubhook = (tracks: (RCLocalTrack | IPublishAttrs)[]) => Pubh
 /**
  * 资源发布命令
  */
-export declare class PubCommand extends BaseCommand<IPubSuccessRes> {
+export declare class PublishCommand extends BaseCommand<IPubSuccessRes> {
     private tracks;
     private pubhook;
     constructor(tracks: (RCLocalTrack | IPublishAttrs)[], pubhook: Pubhook);
+    get kind(): RCCommandKind;
     /**
      * 从 pc 移除当次发布失败的资源
      */
@@ -31,4 +33,4 @@ export declare class PubCommand extends BaseCommand<IPubSuccessRes> {
     private _mergePublishRes;
     execute(store: Store, invoker: Invoker): Promise<IPubSuccessRes>;
 }
-//# sourceMappingURL=PubCommand.d.ts.map
+//# sourceMappingURL=PublishCommand.d.ts.map

package/dist/core/command/{SubCommand.d.ts → SubscribeCommand.d.ts}

@@ -4,18 +4,18 @@ import { Invoker } from '../Invoker';
 import { Store } from '../Store';
 import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
 import { BaseCommand } from './BaseCommand';
-import { Subhook } from './UpdateSubListCommand';
-export declare class SubCommand extends BaseCommand<{
+import { Subscribehook } from './UpdateSubscribeListCommand';
+export declare class SubscribeCommand extends BaseCommand<{
     code: RCRTCCode;
     failedList?: ISubscribeAttr[];
 }> {
     private readonly tracks;
     private subhook;
     private readonly forceReq?;
-    constructor(tracks: (RCRemoteTrack | ISubscribeAttr)[], subhook: Subhook, forceReq?: boolean | undefined);
+    constructor(tracks: (RCRemoteTrack | ISubscribeAttr)[], subhook: Subscribehook, forceReq?: boolean | undefined);
     execute(store: Store, invoker: Invoker): Promise<{
         code: RCRTCCode;
         failedList?: ISubscribeAttr[];
     }>;
 }
-//# sourceMappingURL=SubCommand.d.ts.map
+//# sourceMappingURL=SubscribeCommand.d.ts.map

package/dist/core/command/{UnpubCommand.d.ts → UnpublishCommand.d.ts}

@@ -1,3 +1,4 @@
+import { RCCommandKind } from '../enums/RCCommandKind';
 import { IPublishAttrs, IPubSuccessRes } from '../interfaces';
 import { Invoker } from '../Invoker';
 import { IPushOtherRooms, IRTCReqHeader } from '../service/interface';
@@ -9,12 +10,13 @@ export declare type UnpubhookRes = {
     headers: IRTCReqHeader;
 };
 export declare type Unpubhook = (tracks: (RCLocalTrack | IPublishAttrs)[], pcName: string) => UnpubhookRes;
-export declare class UnpubCommand extends BaseCommand<IPubSuccessRes> {
+export declare class UnpublishCommand extends BaseCommand<IPubSuccessRes> {
     private tracks;
     private unpubhook;
     constructor(tracks: RCLocalTrack[], unpubhook: Unpubhook);
+    get kind(): RCCommandKind;
     private __unpublish;
     private _mergeUnpublishRes;
     execute(store: Store, invoker: Invoker): Promise<IPubSuccessRes>;
 }
-//# sourceMappingURL=UnpubCommand.d.ts.map
+//# sourceMappingURL=UnpublishCommand.d.ts.map

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

@@ -0,0 +1,11 @@
+import { Store } from '../Store';
+import { BaseCommand } from './BaseCommand';
+/**
+ * 加入房间后，若房间中已存在己方发布的资源，表示之前未能完成正常退出流程
+ * 需先清除房间内的己方资源，通知房间内其他人己方已取消当前资源的发布
+ * 该步骤没有必要与 MediaServer 的交互，因后续资源变更交互为全量交互
+ */
+export declare class UnpublishPrevCommand extends BaseCommand<void> {
+    execute(store: Store): Promise<void>;
+}
+//# sourceMappingURL=UnpublishPrevCommand.d.ts.map

package/dist/core/command/{UnsubCommand.d.ts → UnsubscribeCommand.d.ts}

@@ -4,17 +4,17 @@ import { Invoker } from '../Invoker';
 import { Store } from '../Store';
 import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
 import { BaseCommand } from './BaseCommand';
-import { Subhook } from './UpdateSubListCommand';
-export declare class UnsubCommand extends BaseCommand<{
+import { Subscribehook } from './UpdateSubscribeListCommand';
+export declare class UnsubscribeCommand extends BaseCommand<{
     code: RCRTCCode;
     failedList?: ISubscribeAttr[];
 }> {
     private tracks;
     private subhook;
-    constructor(tracks: RCRemoteTrack[], subhook: Subhook);
+    constructor(tracks: RCRemoteTrack[], subhook: Subscribehook);
     execute(store: Store, invoker: Invoker): Promise<{
         code: RCRTCCode;
         failedList?: ISubscribeAttr[];
     }>;
 }
-//# sourceMappingURL=UnsubCommand.d.ts.map
+//# sourceMappingURL=UnsubscribeCommand.d.ts.map

package/dist/core/command/{UpdateSubListCommand.d.ts → UpdateSubscribeListCommand.d.ts}

@@ -6,23 +6,23 @@ import { Store } from '../Store';
 import { RCRemoteTrack } from '../tracks/RCRemoteTrack';
 import RCRTCPeerConnection from '../webrtc/RCRTCPeerConnection';
 import { BaseCommand } from './BaseCommand';
-export declare type SubhookRes = {
+export declare type SubscribehookRes = {
     pc: RCRTCPeerConnection;
     pushOtherRooms: IPushOtherRooms[];
     headers: IRTCReqHeader;
 };
-export declare type Subhook = (tracks: (RCRemoteTrack | ISubscribeAttr)[]) => SubhookRes;
-export declare class UpdateSubListCommand extends BaseCommand<{
+export declare type Subscribehook = (tracks: (RCRemoteTrack | ISubscribeAttr)[]) => SubscribehookRes;
+export declare class UpdateSubscribeListCommand extends BaseCommand<{
     code: RCRTCCode;
     failedList?: ISubscribeAttr[];
 }> {
     private readonly tracks;
     private subhook;
     private readonly forceReq?;
-    constructor(tracks: (RCRemoteTrack | ISubscribeAttr)[], subhook: Subhook, forceReq?: boolean | undefined);
+    constructor(tracks: (RCRemoteTrack | ISubscribeAttr)[], subhook: Subscribehook, forceReq?: boolean | undefined);
     execute(store: Store, invoker: Invoker): Promise<{
         code: RCRTCCode;
         failedList?: ISubscribeAttr[];
     }>;
 }
-//# sourceMappingURL=UpdateSubListCommand.d.ts.map
+//# sourceMappingURL=UpdateSubscribeListCommand.d.ts.map

package/dist/core/enums/RCCommandKind.d.ts

@@ -0,0 +1,12 @@
+export declare enum RCCommandKind {
+    Unknow = 0,
+    Publish = 1,
+    UnPublish = 2,
+    JoinRoom = 3,
+    LeaveRoom = 4,
+    UpdateSubscribeTask = 5,
+    SubscribedTask = 6,
+    UnSubscribedTask = 7,
+    AsyncCommand = "AsyncCommand"
+}
+//# sourceMappingURL=RCCommandKind.d.ts.map

package/dist/core/enums/RCLinkedListPoint.d.ts

@@ -0,0 +1,6 @@
+export declare enum RCLinkedListPoint {
+    NORMAL = "normal",
+    MIDDLE = "middle",
+    TAIL = "tail"
+}
+//# sourceMappingURL=RCLinkedListPoint.d.ts.map

package/dist/core/enums/RCLoggerTag.d.ts

@@ -606,7 +606,19 @@ export declare enum RCLoggerTag {
     /**
      * 设置 SDP 上的码率
      */
-    L_RTC_SDP_BITRATE_O = "L_rtc_sdp_bitrate_O"
+    L_RTC_SDP_BITRATE_O = "L_rtc_sdp_bitrate_O",
+    /**
+     * 3A 降噪
+     */
+    L_RTC_3ANOISE_NODE_O = "L_RTC_AAAnoiseNode_O",
+    /**
+     * 3A 降噪
+     */
+    L_RTC_3ANOISE_NODE_E = "L_RTC_AAAnoiseNode_E",
+    /**
+     * 3A 降噪
+     */
+    L_RTC_3ANOISE_NODE_STOP_O = "L_RTC_AAAnoiseNode_Stop_O"
 }
 export declare enum RCLoggerStatus {
     /**

package/dist/core/enums/inner/RCRTCMessageType.d.ts

@@ -61,6 +61,10 @@ export declare enum RCRTCMessageType {
     /**
      * 连麦的房间不再了或离线了，主直播房间会收到的消息通知
      */
-    OTHER_ROOM_OFFLINE = "RCRTC:otherRoomOffline"
+    OTHER_ROOM_OFFLINE = "RCRTC:otherRoomOffline",
+    /**
+     * 订阅、取消订阅动作成功
+     */
+    ROOM_TASK_FINISH = "RCRTC:roomTaskFinish"
 }
 //# sourceMappingURL=RCRTCMessageType.d.ts.map

package/dist/core/interfaces.d.ts

@@ -577,6 +577,14 @@ export interface IRoomEventListener extends IRCRTCTrackEventListener {
      * 主播和观众切换身份通知
      */
     onSwitchRole?(userId: string, role: RCRTCLiveRole): void;
+    /**
+     * 房间任务完成时调用的函数。
+     * @param code 任务完成后的状态
+     * @param subscribe 订阅成功的列表
+     * @param unsubscribe 取消订阅成功的列表
+     * @param failedList 订阅失败的列表
+     */
+    onTaskCompleted?(code: RCRTCCode, subscribe: ISubscribeAttr[], unsubscribe: ISubscribeAttr[], failedList: ISubscribeAttr[]): void;
 }
 /**
  * RTCClient 初始化配置
@@ -624,6 +632,17 @@ export interface IRCRTCInitOptions {
      * 观众拉内置 CDN 资源时是否使用 https，默认为 RCInnerCDNPullIsHttps.HTTPS
      */
     pullInnerCDNUseHttps?: RCInnerCDNPullIsHttps;
+    /**
+     * 音频降噪处理
+     * - workletModule 默认值为 https://cdn.ronghub.com/plugin-rtc/wasm/5.0.0-alpha.1/process-worklet.js
+     * - workletWasm 默认值为 https://cdn.ronghub.com/plugin-rtc/wasm/5.0.0-alpha.1/AudioProcessing.wasm
+     * - isOpen 默认值为 false
+     */
+    audio?: {
+        workletModule?: string;
+        workletWasm?: string;
+        isOpen?: boolean;
+    };
 }
 export interface ICameraVideoProfile extends IVideoProfile {
     cameraId?: string;

package/dist/core/room/RCAbstractRoom.d.ts

@@ -250,6 +250,12 @@ export default abstract class RCAbstractRoom extends EventEmitter {
         code: RCRTCCode;
         failedList?: ISubscribeAttr[];
     }>;
+    /**
+     * 它将订阅任务添加到队列中。
+     * @param {(RCRemoteTrack | ISubscribeAttr)[]} tracks - (RCRemoteTrack | ISubscribeAttr)[]
+     * @returns 一个用代码和失败列表解析为对象的承诺。
+     */
+    addSubscribeTask(tracks: (RCRemoteTrack | ISubscribeAttr)[]): void;
     /**
      * 取消订阅资源
      * @param tracks 预取消远端资源
@@ -258,6 +264,27 @@ export default abstract class RCAbstractRoom extends EventEmitter {
         code: RCRTCCode;
         failedList?: ISubscribeAttr[];
     }>;
+    /**
+     * 它将取消订阅任务添加到队列中。
+     * @param {RCRemoteTrack[]} tracks - 要取消订阅的曲目。
+     * @returns 一个用代码和失败列表解析为对象的承诺。
+     */
+    addUnsubscribeTask(tracks: RCRemoteTrack[]): void;
+    /**
+     * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
+     * 当参数为 `[]` 时，意味着不再订阅任何资源
+     * @param tracks 变更的资源列表
+     */
+    updateSubList(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
+    /**
+     * 将任务添加到任务队列的函数。
+     * @param {(RCRemoteTrack | ISubscribeAttr)[]} tracks - (RCRemoteTrack | ISubscribeAttr)[]
+     */
+    addUpdateSubscribeListTask(tracks: (RCRemoteTrack | ISubscribeAttr)[]): void;
+    private _onTaskCompleted;
     /**
      * 获取已发布的本地资源
      * @param trackId
@@ -275,14 +302,10 @@ export default abstract class RCAbstractRoom extends EventEmitter {
      */
     getRemoteTrack(trackId: string): RCRemoteTrack | null;
     /**
-     * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
-     * 当参数为 `[]` 时，意味着不再订阅任何资源
-     * @param tracks 变更的资源列表
+     * 获取当前已经订阅的全量资源
+     * returns subscribedTracks ISubscribeAttr[]
      */
-    updateSubList(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
+    get subscribedTracks(): ISubscribeAttr[];
     private _appListener;
     /**
      * 注册事件监听器，多次注册会导致后者覆盖前者，可以通过使用 `registerRoomEventListener(null)` 取消注册

package/dist/core/room/RCAudienceLivingRoom.d.ts

@@ -221,6 +221,10 @@ export default class RCAudienceLivingRoom {
         code: RCRTCCode;
         failedList?: ISubscribeAttr[];
     }>;
+    addSubscribeTask(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     private __unsubscribe;
     /**
      * 取消订阅资源
@@ -230,6 +234,10 @@ export default class RCAudienceLivingRoom {
         code: RCRTCCode;
         failedList?: ISubscribeAttr[];
     }>;
+    addUnsubscribeTask(tracks: RCRemoteTrack[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
      * 退出房间并销毁当前房间实例，退出后该房间的所有方法将不可用
      */

package/dist/core/tracks/RC3AnoiseTrack.d.ts

@@ -0,0 +1,27 @@
+export default class RC3AnoiseTrack {
+    static workletModule: string;
+    static workletWasm: string;
+    static isOpen: boolean;
+    /**
+     * 该函数接受一个布尔值作为参数，如果没有传递参数，该函数将默认为 true
+     * @param {boolean} [isOpen=true] - 轨道是否开放。
+     */
+    static setStatus(isOpen?: boolean): void;
+    /**
+     * 它设置 worklet 模块和 wasm。
+     * @param {string} module - 将用于创建工作集的模块的名称。
+     * @param {string} wasm - Rust 编译器生成的 wasm 文件。
+     */
+    static setWroklet(module: string, wasm: string): void;
+    /**
+     * 它创建一个 AudioContext，从输入流创建一个 MediaStreamSource，
+     * 创建一个 MediaStreamDestination，创建一个 AudioWorkletNode，并将节点连接在一起。
+     * @param {MediaStream} audioStream - 媒体流
+     * @returns 一个媒体流对象。
+     */
+    static transformStreamTrack(audioStream: MediaStream): Promise<{
+        track: MediaStreamTrack;
+        stop: Function;
+    }>;
+}
+//# sourceMappingURL=RC3AnoiseTrack.d.ts.map