@rongcloud/plugin-rtc 5.4.4-alpha.1 → 5.4.5-alpha.1

package/dist/index.umd.js

@@ -1,7 +1,7 @@
 /*
- * RCRTC - v5.4.4-alpha.1
- * CommitId - 62dca5e7f4d904aeefb9634071be2b9b2f37c61d
- * Tue Aug 02 2022 15:17:41 GMT+0800 (China Standard Time)
+ * RCRTC - v5.4.5-alpha.1
+ * CommitId - 960e964ebd4294c2f095e87cf9e33935703b475e
+ * Fri Aug 12 2022 15:02:10 GMT+0800 (China Standard Time)
  * ©2020 RongCloud, Inc. All rights reserved.
  */
 (function (global, factory) {
@@ -81,7 +81,7 @@
         /** 获取屏幕共享流失败 */
         RCRTCCode[RCRTCCode["GET_DISPLAY_MEDIA_FAILED"] = 53011] = "GET_DISPLAY_MEDIA_FAILED";
         /** 权限问题导致获取媒体流被拒绝 */
-        RCRTCCode[RCRTCCode["PERMISSION_DENIED"] = 53012] = "PERMISSION_DENIED";
+        RCRTCCode[RCRTCCode["BROWSER_PERMISSION_DENIED"] = 53012] = "BROWSER_PERMISSION_DENIED";
         /** 创建自定义流失败 */
         RCRTCCode[RCRTCCode["CREATE_CUSTOM_TRACK_FAILED"] = 53013] = "CREATE_CUSTOM_TRACK_FAILED";
         /** 无效的 TAG 定义 */
@@ -122,6 +122,8 @@
         RCRTCCode[RCRTCCode["SOME_TRACKS_PUBLISH_FAILED"] = 53031] = "SOME_TRACKS_PUBLISH_FAILED";
         /** electron 中 mac 系统暂不支持屏幕共享采集声音 */
         RCRTCCode[RCRTCCode["MAC_IN_ELECTRON_NOT_SUPPORT_SCREEN_SHARE_WITH_AUDIO"] = 53032] = "MAC_IN_ELECTRON_NOT_SUPPORT_SCREEN_SHARE_WITH_AUDIO";
+        /** 获取媒体资源时，无系统权限 */
+        RCRTCCode[RCRTCCode["SYSTEM_PERMISSION_DENIED"] = 53033] = "SYSTEM_PERMISSION_DENIED";
     })(exports.RCRTCCode || (exports.RCRTCCode = {}));
 
     var RCLoggerTag;
@@ -734,6 +736,18 @@
          * 设置 SDP 上的码率
          */
         RCLoggerTag["L_RTC_SDP_BITRATE_O"] = "L_rtc_sdp_bitrate_O";
+        /**
+         * 3A 降噪
+         */
+        RCLoggerTag["L_RTC_3ANOISE_NODE_O"] = "L_RTC_AAAnoiseNode_O";
+        /**
+         * 3A 降噪
+         */
+        RCLoggerTag["L_RTC_3ANOISE_NODE_E"] = "L_RTC_AAAnoiseNode_E";
+        /**
+         * 3A 降噪
+         */
+        RCLoggerTag["L_RTC_3ANOISE_NODE_STOP_O"] = "L_RTC_AAAnoiseNode_Stop_O";
     })(RCLoggerTag || (RCLoggerTag = {}));
     var RCLoggerStatus;
     (function (RCLoggerStatus) {
@@ -6330,6 +6344,13 @@
         __innerGetMediaStreamTrack() {
             return this._msTrack;
         }
+        /**
+         * 它返回 MediaStreamTrack 对象。
+         * @returns 表示媒体源的 MediaStreamTrack 对象。
+         */
+        get streamTrack() {
+            return this._msTrack;
+        }
         /**
          * 获取数据标识
          * @returns
@@ -6424,8 +6445,7 @@
          * @param element 用于承载媒体流的元素标签，音频流可传空
          * @param volume 有效值为 0-100
          */
-        play(element, options = { autoplay: true }) {
-            var _a, _b;
+        play(element, options) {
             return __awaiter(this, void 0, void 0, function* () {
                 engine.logger.info(RCLoggerTag.L_TRACK_PLAY_T, {
                     element,
@@ -6583,46 +6603,42 @@
                         logSource: engine.LogSource.RTC
                     });
                 };
-                // 用户在 Video 标签上 设置的优化级最高，其次是选项中设置的 autoplay
-                const autoplay = ((_a = this._element) === null || _a === void 0 ? void 0 : _a.getAttribute('autoplay')) === null ? options.autoplay : (_b = this._element) === null || _b === void 0 ? void 0 : _b.autoplay;
                 this._element.oncanplay = (evt) => __awaiter(this, void 0, void 0, function* () {
-                    var _c, _d, _e;
+                    var _a, _b, _c;
                     // 可以播放
-                    logger.info(`HTMLMediaElement oncanplay -> id: ${(_c = evt.target) === null || _c === void 0 ? void 0 : _c.id}, trackId: ${this._id}`);
+                    logger.info(`HTMLMediaElement oncanplay -> id: ${(_a = evt.target) === null || _a === void 0 ? void 0 : _a.id}, trackId: ${this._id}`);
                     engine.logger.info(RCLoggerTag.L_TRACK_PLAY_R, {
                         status: RCLoggerStatus.INFO,
-                        msg: `HTMLMediaElement oncanplay -> id: ${(_d = evt.target) === null || _d === void 0 ? void 0 : _d.id}, trackId: ${this._id}`
+                        msg: `HTMLMediaElement oncanplay -> id: ${(_b = evt.target) === null || _b === void 0 ? void 0 : _b.id}, trackId: ${this._id}`
                     }, {
                         logSource: engine.LogSource.RTC
                     });
-                    if (autoplay) {
-                        try {
-                            (_e = this._element) === null || _e === void 0 ? void 0 : _e.play();
-                        }
-                        catch (error) {
-                            /**
-                             * 检测是否有设置音频输出设备的权限
-                             */
-                            if (error.message === 'No permission to use requested device') {
-                                logger.error(`setSinkId failed -> ${error.message}`);
-                                engine.logger.error(RCLoggerTag.L_TRACK_PLAY_R, {
-                                    status: RCLoggerStatus.FAILED,
-                                    code: exports.RCRTCCode.NO_PERMISSION_TO_USE_REQUESTED_DEVICE,
-                                    msg: 'No permission'
-                                }, {
-                                    logSource: engine.LogSource.RTC
-                                });
-                                return;
-                            }
-                            logger.error(error);
+                    try {
+                        (_c = this._element) === null || _c === void 0 ? void 0 : _c.play();
+                    }
+                    catch (error) {
+                        /**
+                         * 检测是否有设置音频输出设备的权限
+                         */
+                        if (error.message === 'No permission to use requested device') {
+                            logger.error(`setSinkId failed -> ${error.message}`);
                             engine.logger.error(RCLoggerTag.L_TRACK_PLAY_R, {
                                 status: RCLoggerStatus.FAILED,
-                                code: exports.RCRTCCode.TRACK_PLAY_ERROR,
-                                msg: 'play error'
+                                code: exports.RCRTCCode.NO_PERMISSION_TO_USE_REQUESTED_DEVICE,
+                                msg: 'No permission'
                             }, {
                                 logSource: engine.LogSource.RTC
                             });
+                            return;
                         }
+                        logger.error(error);
+                        engine.logger.error(RCLoggerTag.L_TRACK_PLAY_R, {
+                            status: RCLoggerStatus.FAILED,
+                            code: exports.RCRTCCode.TRACK_PLAY_ERROR,
+                            msg: 'play error'
+                        }, {
+                            logSource: engine.LogSource.RTC
+                        });
                     }
                 });
                 this._element.onvolumechange = evt => {
@@ -6638,7 +6654,7 @@
                     });
                 };
                 this._element.srcObject = this._msStream;
-                this._element.autoplay = autoplay;
+                this._element.autoplay = true;
                 // video 标签页面内播放
                 if (isVideoTrack) {
                     this._element.playsInline = true;
@@ -6740,6 +6756,106 @@
         [exports.RCVideoBitrate.LEVEL5]: { max: 4000, min: 400 }
     };
 
+    class RC3AnoiseTrack {
+        /**
+         * 该函数接受一个布尔值作为参数，如果没有传递参数，该函数将默认为 true
+         * @param {boolean} [isOpen=true] - 轨道是否开放。
+         */
+        static setStatus(isOpen = true) {
+            RC3AnoiseTrack.isOpen = isOpen;
+        }
+        /**
+         * 它设置 worklet 模块和 wasm。
+         * @param {string} module - 将用于创建工作集的模块的名称。
+         * @param {string} wasm - Rust 编译器生成的 wasm 文件。
+         */
+        static setWroklet(module, wasm) {
+            RC3AnoiseTrack.workletModule = module;
+            RC3AnoiseTrack.workletModule = wasm;
+        }
+        /**
+         * 它创建一个 AudioContext，从输入流创建一个 MediaStreamSource，
+         * 创建一个 MediaStreamDestination，创建一个 AudioWorkletNode，并将节点连接在一起。
+         * @param {MediaStream} audioStream - 媒体流
+         * @returns 一个媒体流对象。
+         */
+        static transformStreamTrack(audioStream) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                /* 如果开关未打开则直接返回 音轨。 */
+                if (!RC3AnoiseTrack.isOpen) {
+                    return new Promise(resolve => {
+                        resolve({
+                            track: audioStream === null || audioStream === void 0 ? void 0 : audioStream.getAudioTracks()[0],
+                            stop: () => { }
+                        });
+                    });
+                }
+                // 创建 AudioContext 并设定采集频率
+                const audioCxt = new AudioContext({ sampleRate: 44100 });
+                // 创建资源
+                const renoise = audioCxt.createMediaStreamSource(audioStream);
+                // 最终发布的音频载体
+                const destination = audioCxt.createMediaStreamDestination();
+                const AAAnoiseWorklet = yield audioCxt.audioWorklet.addModule(RC3AnoiseTrack.workletModule).then(() => {
+                    logger.info(RCLoggerTag.L_RTC_3ANOISE_NODE_O, {
+                        status: RCLoggerStatus.SUCCESSED,
+                        message: { msg: 'addModule RC3AnoiseTrack.workletModule success' }
+                    }, {
+                        logSource: engine.LogSource.RTC
+                    });
+                    return fetch(RC3AnoiseTrack.workletWasm, {
+                        credentials: 'same-origin'
+                    }).then(function (response) {
+                        return response.arrayBuffer();
+                    }).catch(error => {
+                        throw new Error(error.message);
+                    });
+                }).then(buffer => {
+                    const AAAnoiseNode = new AudioWorkletNode(audioCxt, 'process-worklet', {
+                        numberOfInputs: 1,
+                        numberOfOutputs: 1,
+                        outputChannelCount: [1],
+                        processorOptions: {
+                            binary: buffer
+                        }
+                    });
+                    return AAAnoiseNode;
+                }).catch(err => {
+                    logger.info(RCLoggerTag.L_RTC_3ANOISE_NODE_E, {
+                        status: RCLoggerStatus.FAILED,
+                        message: { msg: err.message }
+                    }, {
+                        logSource: engine.LogSource.RTC
+                    });
+                });
+                if (!AAAnoiseWorklet) {
+                    return new Promise(resolve => {
+                        resolve({
+                            track: audioStream === null || audioStream === void 0 ? void 0 : audioStream.getAudioTracks()[0],
+                            stop: () => { }
+                        });
+                    });
+                }
+                const stop = () => {
+                    logger.info(RCLoggerTag.L_RTC_3ANOISE_NODE_STOP_O, {
+                        status: RCLoggerStatus.SUCCESSED,
+                        message: { msg: 'call stop RC3AnoiseTrack.workletModule' }
+                    }, {
+                        logSource: engine.LogSource.RTC
+                    });
+                    AAAnoiseWorklet === null || AAAnoiseWorklet === void 0 ? void 0 : AAAnoiseWorklet.port.postMessage({ type: 'stop', msg: '' });
+                };
+                renoise.connect(AAAnoiseWorklet).connect(destination);
+                const track = (_a = destination === null || destination === void 0 ? void 0 : destination.stream) === null || _a === void 0 ? void 0 : _a.getAudioTracks()[0];
+                return { track, stop };
+            });
+        }
+    }
+    RC3AnoiseTrack.workletModule = 'https://cdn.ronghub.com/plugin-rtc/wasm/5.0.0-alpha.1/process-worklet.js';
+    RC3AnoiseTrack.workletWasm = 'https://cdn.ronghub.com/plugin-rtc/wasm/5.0.0-alpha.1/AudioProcessing.wasm';
+    RC3AnoiseTrack.isOpen = false;
+
     /* eslint no-dupe-class-members: 'off' */
     class RCLocalTrack extends RCTrack {
         constructor(tag, userId, kind, track) {
@@ -6871,6 +6987,7 @@
     class RCLocalAudioTrack extends RCLocalTrack {
         constructor(tag, userId, track) {
             super(tag, userId, 'audio', track);
+            this._stopProcess = () => { };
         }
         /**
          * 它设置推荐的音频码率。
@@ -6898,6 +7015,31 @@
             const [min = 1, start = max * 0.7 || 1] = args;
             super.setBitrate(max, min, start);
         }
+        /**
+         * @override __innerSetMediaStreamTrack
+         * @params {track} MediaStreamTrack 添加音频流
+         * @params {track} undefined        销毁音频流
+         */
+        __innerSetMediaStreamTrack(track) {
+            if (!track) {
+                // 如果 track 为 undefined 则为销毁动作
+                super.__innerSetMediaStreamTrack(track);
+                this._stopProcess();
+            }
+            else {
+                // 是否开启3A降噪
+                if (RC3AnoiseTrack.isOpen) {
+                    const audioStream = new MediaStream([track]);
+                    RC3AnoiseTrack.transformStreamTrack(audioStream).then(({ track, stop }) => {
+                        super.__innerSetMediaStreamTrack(track);
+                        this._stopProcess = stop;
+                    });
+                }
+                else {
+                    super.__innerSetMediaStreamTrack(track);
+                }
+            }
+        }
     }
     class RCLocalVideoTrack extends RCLocalTrack {
         constructor(tag, userId, track, _isTiny = false) {
@@ -6989,6 +7131,7 @@
     class RCLocalFileAudioTrack extends RCLocalFileTrack {
         constructor(tag, userId, track, element) {
             super(tag, userId, 'audio', track, element);
+            this._stopProcess = () => { };
         }
         _setLocalMuted(bool) {
             if (this._resource) {
@@ -7001,6 +7144,31 @@
             this._setLocalMuted(false);
             return Promise.resolve({ code: exports.RCRTCCode.SUCCESS });
         }
+        /**
+         * @override __innerSetMediaStreamTrack
+         * @params {track} MediaStreamTrack 添加音频流
+         * @params {track} undefined        销毁音频流
+         */
+        __innerSetMediaStreamTrack(track) {
+            if (!track) {
+                // 如果 track 为 undefined 则为销毁动作
+                super.__innerSetMediaStreamTrack(track);
+                this._stopProcess();
+            }
+            else {
+                // 是否开启3A降噪
+                if (RC3AnoiseTrack.isOpen) {
+                    const audioStream = new MediaStream([track]);
+                    RC3AnoiseTrack.transformStreamTrack(audioStream).then(({ track, stop }) => {
+                        super.__innerSetMediaStreamTrack(track);
+                        this._stopProcess = stop;
+                    });
+                }
+                else {
+                    super.__innerSetMediaStreamTrack(track);
+                }
+            }
+        }
     }
     class RCMicphoneAudioTrack extends RCLocalAudioTrack {
     }
@@ -7048,6 +7216,16 @@
     class RCRemoteVideoTrack extends RCRemoteTrack {
         constructor(tag, userId, roomId) {
             super(tag, userId, 'video', roomId);
+            this._isSubTiny = false;
+        }
+        __innerSetIsTinyTrack(bool) {
+            this._isSubTiny = bool;
+        }
+        /**
+         * 是否订阅的小流
+         */
+        isSubTiny() {
+            return this._isSubTiny;
         }
     }
 
@@ -7518,6 +7696,10 @@
          * 连麦的房间不再了或离线了，主直播房间会收到的消息通知
          */
         RCRTCMessageType["OTHER_ROOM_OFFLINE"] = "RCRTC:otherRoomOffline";
+        /**
+         * 订阅、取消订阅动作成功
+         */
+        RCRTCMessageType["ROOM_TASK_FINISH"] = "RCRTC:roomTaskFinish";
     })(RCRTCMessageType || (RCRTCMessageType = {}));
 
     exports.RCRTCPingResult = void 0;
@@ -7677,7 +7859,7 @@
         'Content-Type': 'application/json;charset=UTF-8',
         'Cache-Control': 'no-cache',
         ClientType: `web|${browserInfo.browser}|${browserInfo.version}`,
-        ClientVersion: "5.4.4-alpha.1",
+        ClientVersion: "5.4.5-alpha.1",
         'Client-Session-Id': getUUID(),
         'Request-Id': Date.now().toString()
     });
@@ -7999,7 +8181,7 @@
             audioLevel = audioLevel / 32767;
         }
         const rate = 10 ** factor;
-        return Math.ceil(audioLevel * rate);
+        return Math.round(audioLevel * rate);
     };
     /**
      * 计算丢包率
@@ -8979,7 +9161,7 @@
             for (let mid = 1; mid < streams.length; mid++) {
                 const stream = this.SDP.substring(streams[mid], streams[mid + 1]);
                 // 移除不需要发布资源的 ssrc
-                const sendonlyStream = this.clearInactiveOrRecvonly(stream);
+                const sendonlyStream = ASdpBuilder.clearInactiveOrRecvonly(stream);
                 if (sendonlyStream) {
                     if (/^\bm=video\b/.test(stream)) {
                         this.videoStreams.push(stream);
@@ -8996,7 +9178,7 @@
          * @param {string} stream - string - 要修改的 SDP 字符串
          * @returns 正在返回流。
          */
-        clearInactiveOrRecvonly(stream) {
+        static clearInactiveOrRecvonly(stream) {
             const recvonlyORinactive = /\ba=(recvonly|inactive)\b/.test(stream);
             if (recvonlyORinactive) {
                 return stream.replace(/\r\na=(ssrc|msid)[^\r\n]+/ig, '');
@@ -9374,7 +9556,7 @@
                     offer.sdp = offer.sdp.replace(new RegExp(streamId, 'g'), msid);
                 }
                 if (offer.sdp) {
-                    offer.sdp = this.resetSdp(offer.sdp);
+                    offer.sdp = ASdpBuilder.clearInactiveOrRecvonly(offer.sdp);
                 }
                 yield this._peer.setLocalDescription(offer);
                 return { type: 'offer', semantics: 'plan-b', sdp: offer.sdp };
@@ -9588,7 +9770,8 @@
                     const streamId = this._outboundStreams[msid].id;
                     sdp = sdp.replace(new RegExp(streamId, 'g'), msid);
                 }
-                sdp = this.resetSdp(sdp);
+                // sdp = this.resetSdp(sdp!)
+                sdp = ASdpBuilder.clearInactiveOrRecvonly(sdp);
                 // 增加 a=ice-options:renomination 行
                 sdp = sdp.replace(/(a=ice-options:trickle)/g, '$1\r\na=ice-options:renomination');
                 offer.sdp = sdp;
@@ -9970,12 +10153,6 @@
                  * 获取 report 中的 iceCandidatePair、senders、receivers 中的所有字段
                  */
                 const formatData = (_b = this.reportParser) === null || _b === void 0 ? void 0 : _b.formatRCRTCStateReport(data);
-                engine.logger.info(RCLoggerTag.L_RTC_PEER_CONNECTION_GET_STATS_DATA_O, {
-                    status: RCLoggerStatus.SUCCESSED,
-                    formatData
-                }, {
-                    logSource: engine.LogSource.RTC
-                });
                 return formatData;
             });
         }
@@ -10275,7 +10452,7 @@
          * 加入房间
          */
         sendR1() {
-            const rtcVersion = "5.4.4-alpha.1";
+            const rtcVersion = "5.4.5-alpha.1";
             const imVersion = this._context.getCoreVersion();
             const platform = 'web';
             const pcName = navigator.platform;
@@ -10477,11 +10654,14 @@
         }
         /**
          * 创建一组 peerC
+         * 为了适应多 peerConnection 的场景做出的冗余设计，对单 peerConnection 进行数组进行封装
+         * 提示：useMutilPeerC 用户自定义的，没有明确场景，必须使用多 peerConnection
          * @param pcName
          * @returns
          */
         createPeerCList(tracks) {
             const peerCArr = [];
+            // isPublish 判断tracks中的资源是否为本地发布资源 从而区分是订阅与发布
             const isPub = this._isPub(tracks);
             // 不使用多 peerConnection
             if (!this._useMutilPeerC) {
@@ -10563,12 +10743,47 @@
         }
     }
 
+    /* 定义命令类型 */
+    var RCCommandKind;
+    (function (RCCommandKind) {
+        // 未定议的
+        RCCommandKind[RCCommandKind["Unknow"] = 0] = "Unknow";
+        // 发布资源
+        RCCommandKind[RCCommandKind["Publish"] = 1] = "Publish";
+        // 取消发布资源
+        RCCommandKind[RCCommandKind["UnPublish"] = 2] = "UnPublish";
+        // 加入房间
+        RCCommandKind[RCCommandKind["JoinRoom"] = 3] = "JoinRoom";
+        // 离开房间
+        RCCommandKind[RCCommandKind["LeaveRoom"] = 4] = "LeaveRoom";
+        // 更新订阅列表
+        RCCommandKind[RCCommandKind["UpdateSubscribeTask"] = 5] = "UpdateSubscribeTask";
+        // 资源订阅
+        RCCommandKind[RCCommandKind["SubscribedTask"] = 6] = "SubscribedTask";
+        // 取消资源订阅
+        RCCommandKind[RCCommandKind["UnSubscribedTask"] = 7] = "UnSubscribedTask";
+        // 异步事件命令
+        RCCommandKind["AsyncCommand"] = "AsyncCommand";
+    })(RCCommandKind || (RCCommandKind = {}));
+
+    // 描述 链表 中的位置
+    var RCLinkedListPoint;
+    (function (RCLinkedListPoint) {
+        RCLinkedListPoint["NORMAL"] = "normal";
+        RCLinkedListPoint["MIDDLE"] = "middle";
+        RCLinkedListPoint["TAIL"] = "tail";
+    })(RCLinkedListPoint || (RCLinkedListPoint = {}));
+
     var CommandPriority;
     (function (CommandPriority) {
         CommandPriority[CommandPriority["LOW"] = 0] = "LOW";
         CommandPriority[CommandPriority["NORMAL"] = 1] = "NORMAL";
         CommandPriority[CommandPriority["HIGH"] = 2] = "HIGH";
     })(CommandPriority || (CommandPriority = {}));
+    var CommandCode;
+    (function (CommandCode) {
+        CommandCode[CommandCode["Destroy"] = 40400] = "Destroy";
+    })(CommandCode || (CommandCode = {}));
     /**
      * 命令基类
      */
@@ -10579,8 +10794,103 @@
         get priority() {
             return CommandPriority.LOW;
         }
+        /**
+         * 它返回命令的种类。
+         * @returns 命令的种类。
+         */
+        get kind() {
+            return RCCommandKind.Unknow;
+        }
     }
 
+    class AsyncCommand extends BaseCommand {
+        constructor(state = RCLinkedListPoint.NORMAL) {
+            super();
+            this.state = state;
+        }
+        get kind() {
+            return RCCommandKind.AsyncCommand;
+        }
+        /**
+         * `public setState（状态：RCLinkedListPoint）：void`
+         *
+         * 该函数是公共的，它被称为 setState，它接受一个称为 state 的参数，它什么也不返回
+         * @param {RCLinkedListPoint} state - 链表的状态。
+         */
+        setState(state) {
+            this.state = state;
+        }
+        /**
+         * 该功能用于向房间发送消息，任务完成时向房间发送消息
+         * @param {Store} store - 店铺
+         * @param {RCRTCCode} code - 任务的状态码，即任务的状态码。
+         * @param {ISubscribeAttr[]} tracks - 要订阅的Tracks
+         */
+        pickoutSubscribed(subscribedTracks, originTracks) {
+            // const roomId: string = store.roomId
+            const { unsubscribe, subscribe } = this.calcSubscribeList(subscribedTracks, originTracks);
+            // 收集成功任务日志列表
+            // 清空列表
+            AsyncCommand.AsyncSubscribeTasks = [];
+            AsyncCommand.AsyncUnsubscribeTasks = [];
+            AsyncCommand.AsyncUpdateSubscribeTasks = [];
+            return { subscribe, unsubscribe };
+        }
+        calcSubscribeList(newTracks, oldTracks) {
+            const unsubscribe = [];
+            const unsubscribeSet = new Set();
+            const subscribe = [];
+            const subscribeSet = new Set();
+            const subscribedTracks = this.formateTrack(newTracks);
+            const originTracks = this.formateTrack(oldTracks);
+            originTracks.forEach(item => {
+                const key = `${item.track.getTrackId()}_SUB_${item.subTiny ? '0' : '1'}`;
+                if (!this.trackInSubscribeList(item, subscribedTracks) && !unsubscribeSet.has(key)) {
+                    unsubscribe.push(item);
+                    unsubscribeSet.add(key);
+                }
+            });
+            subscribedTracks.forEach(item => {
+                const key = `${item.track.getTrackId()}_SUB_${item.subTiny ? '0' : '1'}`;
+                if (!this.trackInSubscribeList(item, originTracks) && !subscribeSet.has(key)) {
+                    subscribe.push(item);
+                    subscribeSet.add(key);
+                }
+            });
+            return { unsubscribe, subscribe };
+        }
+        /**
+         * 它需要一个轨道数组并返回一个轨道数组。
+         * @param {(RCRemoteTrack | ISubscribeAttr)[]} tracks - (RCRemoteTrack | ISubscribeAttr)[]
+         * @returns 具有 track 属性的对象数组。
+         */
+        formateTrack(tracks) {
+            return tracks.map(item => {
+                return item instanceof RCRemoteTrack ? { track: item, subTiny: false } : Object.assign({ subTiny: false }, item);
+            });
+        }
+        /**
+         * 它检查 Track 是否已经在订阅列表中。
+         * @param {ISubscribeAttr} track - ISubscribeAttr：要添加到列表中的 track
+         * @param {ISubscribeAttr[]} tracks - 需要订阅的 track 数组
+         */
+        trackInSubscribeList(track, subscribedTracks) {
+            if (subscribedTracks.length === 0) {
+                return false;
+            }
+            const trackIndex = subscribedTracks.findIndex(item => {
+                if (item.track.getTrackId() === track.track.getTrackId()) {
+                    return item.subTiny === track.subTiny;
+                }
+                return false;
+            });
+            return trackIndex > -1;
+        }
+    }
+    AsyncCommand.AsyncSubscribeTasks = [];
+    AsyncCommand.AsyncUnsubscribeTasks = [];
+    AsyncCommand.AsyncUpdateSubscribeTasks = [];
+
     class ReadableStore {
         constructor(context, service, peerMgr, roomId, crtUserId, roomMode, polarisReport, isUpgrade, isMainRoom) {
             this.context = context;
@@ -10600,6 +10910,7 @@
              * 已订阅参数
              */
             this._subscribedList = [];
+            this._collectSubscribeList = [];
             /**
              * cdn_uris 信令扩散数据
              */
@@ -10641,6 +10952,9 @@
         getSubscribedList() {
             return this._subscribedList;
         }
+        getCollectSubscribeList() {
+            return this._collectSubscribeList;
+        }
         getPublishedResourceByTrackId(trackId) {
             const { userId } = parseTrackId(trackId);
             return this._roomResources[userId].find(item => getTrackId(item) === trackId);
@@ -10736,6 +11050,13 @@
         setCDNUris(uris) {
             this._CDNUris = uris;
         }
+        resetSubscribedList(subscribeList) {
+            this._subscribedList.splice(0, this._subscribedList.length, ...subscribeList);
+            this.resetCollectSubscribeList(subscribeList);
+        }
+        resetCollectSubscribeList(collectSubscribeList) {
+            this._collectSubscribeList.splice(0, this._collectSubscribeList.length, ...collectSubscribeList);
+        }
     }
 
     class BaseInvoker {
@@ -10769,6 +11090,9 @@
                 const { command, resolve, reject } = this._queue.shift();
                 let res;
                 try {
+                    /**
+                     * 说明：由于是先弹出 再执行 Command，所以不存在 在队列中正在执行的任务
+                     */
                     res = yield command.execute(this._store, this);
                 }
                 catch (error) {
@@ -10786,6 +11110,16 @@
                 if (this._isDestroyed) {
                     return;
                 }
+                // 合并具有相同功能的 Command
+                // 由于 Subscribed 与 UnSubscribed 是全量订阅的，
+                // 所以只要队列中存在中 Subscribed 或 UnSubscribed 则可以只执行最后一个
+                const kind = command.kind;
+                if (this._queue.length > 0) {
+                    if (kind === RCCommandKind.AsyncCommand) {
+                        // 重写 resolve, reject 并将使用新回调的进行包裹它
+                        ({ command, resolve, reject } = this.commandOffset(command, resolve, reject));
+                    }
+                }
                 // 根据 command 优先级确定其在队列中的位置
                 const priority = command.priority;
                 // 优化队列输入权重为 0 时直接插入队列最未端即可
@@ -10798,8 +11132,60 @@
                     const postion = index === -1 ? this._queue.length - 1 : index;
                     this._queue.splice(postion, 0, { command, resolve, reject });
                 }
-                this._execute();
-            });
+                // 防止相同任务频繁处理
+                // 在Push完成后创建一个微任务队列
+                // 在队列内对相同的任务进行处理
+                Promise.resolve().then(() => {
+                    this._execute();
+                });
+                // setTimeout(() => {
+                //   this._execute()
+                // }, 1)
+            });
+        }
+        /**
+         * 查找出 RCCommandKind.AsyncCommand 类型的 Command，并将其从队列中删除
+         * 并使用最新的一次 Command 接管它的 resolve & reject
+         * @param resolve
+         * @param reject
+         * @returns 具有两个属性的对象，resolve 和 reject。
+         */
+        commandOffset(command, resolve, reject) {
+            // 因为一次只可以插入一个 Command 所以查找 只需要在队列最后查找一个即可
+            const index = this._queue.length - 1;
+            const item = this._queue[index];
+            const hashSubscribTask = item.command.kind === RCCommandKind.AsyncCommand;
+            // 如果队列中不存在则直接返回
+            if (!hashSubscribTask) {
+                return { command, resolve, reject };
+            }
+            const [task] = this._queue.splice(index, 1);
+            if (task.command instanceof AsyncCommand) {
+                task.command.setState(RCLinkedListPoint.MIDDLE);
+                if (command instanceof AsyncCommand) {
+                    command.setState(RCLinkedListPoint.TAIL);
+                }
+            }
+            // 重写 command execute 方法
+            const oldexecute = command.execute;
+            /* eslint no-useless-call: 'off' */
+            command.execute = function (store, invoker) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    task.command.execute.call(task.command, store, invoker);
+                    return oldexecute.call(command, store, invoker);
+                });
+            };
+            return {
+                command,
+                resolve: (res) => {
+                    task.resolve.call(task, res);
+                    resolve(res);
+                },
+                reject: (error) => {
+                    task.reject.call(task, error);
+                    reject(error);
+                }
+            };
         }
         isDestroyed() {
             return this._isDestroyed;
@@ -10835,7 +11221,12 @@
         }
     }
 
-    class UnpubPrevCommand extends BaseCommand {
+    /**
+     * 加入房间后，若房间中已存在己方发布的资源，表示之前未能完成正常退出流程
+     * 需先清除房间内的己方资源，通知房间内其他人己方已取消当前资源的发布
+     * 该步骤没有必要与 MediaServer 的交互，因后续资源变更交互为全量交互
+     */
+    class UnpublishPrevCommand extends BaseCommand {
         execute(store) {
             return __awaiter(this, void 0, void 0, function* () {
                 const selfRes = store.getResourcesByUserId(store.crtUserId);
@@ -10868,6 +11259,9 @@
             this.innerUserDatas = innerUserDatas;
             this.outerUserDatas = outerUserDatas;
         }
+        get kind() {
+            return RCCommandKind.JoinRoom;
+        }
         execute(store, invoker) {
             var _a;
             return __awaiter(this, void 0, void 0, function* () {
@@ -10955,7 +11349,7 @@
                  * 需先清除房间内的己方资源，通知房间内其他人己方已取消当前资源的发布
                  * 该步骤没有必要与 MediaServer 的交互，因后续资源变更交互为全量交互
                  */
-                selfRes.length > 0 && invoker.push(new UnpubPrevCommand());
+                selfRes.length > 0 && invoker.push(new UnpublishPrevCommand());
                 const CDNUris = (_a = data.roomInfo.filter((item) => { return item.key === 'cdn_uris'; })[0]) === null || _a === void 0 ? void 0 : _a.value;
                 CDNUris && store.setCDNUris(JSON.parse(CDNUris)[0]);
                 engine.logger.info(logTag, {
@@ -11143,7 +11537,7 @@
         }
     }
 
-    class UpdateSubListCommand extends BaseCommand {
+    class UpdateSubscribeListCommand extends BaseCommand {
         constructor(tracks, subhook, forceReq) {
             super();
             this.tracks = tracks;
@@ -11235,21 +11629,24 @@
                 const subSuccessTrackIds = subscribedList === null || subscribedList === void 0 ? void 0 : subscribedList.map(item => `${item.msid}_${item.mediaType}`);
                 const subSuccessList = attrs.filter(item => subSuccessTrackIds === null || subSuccessTrackIds === void 0 ? void 0 : subSuccessTrackIds.includes(item.track.getTrackId()));
                 const failedList = attrs.filter(item => !(subSuccessTrackIds === null || subSuccessTrackIds === void 0 ? void 0 : subSuccessTrackIds.includes(item.track.getTrackId())));
-                // 更新 remoteTrack.isSubscribed
+                // 更新 remoteTrack.isSubscribed、remoteTrack.isTinyTrack
                 const remoteTracks = store.getRemoteTracks();
                 for (const trackId in remoteTracks) {
                     const subed = subSuccessList.some(item => item.track.getTrackId() === trackId);
                     remoteTracks[trackId].__innerSetSubscribed(subed);
+                    const isTinyTrack = subSuccessList.some(item => (item.track.getTrackId() === trackId && item.subTiny));
+                    remoteTracks[trackId].isVideoTrack() && (remoteTracks[trackId].__innerSetIsTinyTrack(isTinyTrack));
                 }
                 // 更新本地订阅关系
-                const sublist = store.getSubscribedList();
-                sublist.splice(0, sublist.length, ...subSuccessList);
+                // const sublist = store.getSubscribedList()
+                // sublist.splice(0, sublist.length, ...subSuccessList)
+                store.resetSubscribedList(subSuccessList);
                 return failedList.length ? { code: exports.RCRTCCode.SUCCESS, failedList } : { code: exports.RCRTCCode.SUCCESS };
             });
         }
     }
 
-    class UnsubCommand extends BaseCommand {
+    class UnsubscribeCommand extends BaseCommand {
         constructor(tracks, subhook) {
             super();
             this.tracks = tracks;
@@ -11279,7 +11676,6 @@
                 }
                 logger.info(`unsubscribe -> roomId: ${roomId}, tracks: ${tracks.map(getTrackIdFromAttr)}`);
                 // 计算剩余订阅列表
-                // const crtSubList = this._subscribedList.map(item => ({ ...item })).filter(item => !tracks.includes(item.track))
                 const crtSubList = store.getSubscribedList().map(item => (Object.assign({}, item))).filter(item => !tracks.includes(item.track));
                 // 北极星上报
                 store.polarisReport.sendR2(R2Action.SUBSCRIBE, R2Status.END, tracks.map(item => item.getTrackId()));
@@ -11289,8 +11685,7 @@
                 }, {
                     logSource: engine.LogSource.RTC
                 });
-                // return this._updateSubListHandle(crtSubList, false)
-                return new UpdateSubListCommand(crtSubList, this.subhook, false).execute(store, invoker);
+                return new UpdateSubscribeListCommand(crtSubList, this.subhook, false).execute(store, invoker);
             });
         }
     }
@@ -11372,7 +11767,7 @@
                     });
                     if (tracks.length) {
                         // await this.unsubscribe(tracks)
-                        yield new UnsubCommand(tracks, this.subhook).execute(store, invoker);
+                        yield new UnsubscribeCommand(tracks, this.subhook).execute(store, invoker);
                         // tracks.forEach((item) => delete this._remoteTracks[item.getTrackId()])
                         tracks.forEach(item => store.removeRemoteTrack(item.getTrackId()));
                     }
@@ -11399,7 +11794,7 @@
                 // 需要替业务层取消订阅，业务层只需关注 UI 变化
                 const tracks = this.tracks;
                 // await this.unsubscribe(tracks)
-                yield new UnsubCommand(tracks, this.subhook).execute(store, invoker);
+                yield new UnsubscribeCommand(tracks, this.subhook).execute(store, invoker);
                 tracks.forEach(item => {
                     item.__innerDestroy();
                     // delete this._remoteTracks[item.getTrackId()]
@@ -11410,90 +11805,6 @@
         }
     }
 
-    class SubCommand extends BaseCommand {
-        constructor(tracks, subhook, forceReq) {
-            super();
-            this.tracks = tracks;
-            this.subhook = subhook;
-            this.forceReq = forceReq;
-        }
-        execute(store, invoker) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // 取消房间状态检查，房间销毁后，invoker 应直接清空，避免后续执行动作
-                // const roomStatusCode = this._assertRoomDestroyed()
-                // if (roomStatusCode) {
-                //   logger.error(`subscribe failed, room has been destroyed -> roomId: ${this._roomId}`)
-                //   return { code: RCRTCCode.ROOM_HAS_BEEN_DESTROYED }
-                // }
-                const { tracks, forceReq } = this;
-                const roomId = store.roomId;
-                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_T, {
-                    trackIds: tracks.map(getTrackIdFromAttr),
-                    forceReq
-                }, {
-                    logSource: engine.LogSource.RTC
-                });
-                if (!engine.validate('tracks', tracks, () => {
-                    return engine.isArray(tracks) && tracks.length > 0 && tracks.every(item => {
-                        return item instanceof RCRemoteTrack || item.track instanceof RCRemoteTrack;
-                    });
-                }, true)) {
-                    logger.warn(`subscribe failed, tracks is invalid -> roomId: ${roomId}`);
-                    engine.logger.error(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
-                        status: RCLoggerStatus.FAILED,
-                        code: exports.RCRTCCode.PARAMS_ERROR,
-                        msg: 'params error -> tracks'
-                    }, {
-                        logSource: engine.LogSource.RTC
-                    });
-                    return { code: exports.RCRTCCode.PARAMS_ERROR };
-                }
-                logger.info(`subscribe -> roomId: ${roomId}, tracks: ${tracks.map(getTrackIdFromAttr)}`);
-                // const crtSubList = this._subscribedList.map(item => ({ ...item }))
-                const crtSubList = store.getSubscribedList().map(item => (Object.assign({}, item)));
-                const attrs = tracks.map(item => {
-                    return item instanceof RCRemoteTrack ? { track: item } : item;
-                });
-                let changed = false;
-                const R2TrackIds = [];
-                attrs.forEach(item => {
-                    const trackId = item.track.getTrackId();
-                    R2TrackIds.push(trackId);
-                    const crt = crtSubList.find(tmp => tmp.track.getTrackId() === trackId);
-                    if (crt && crt.subTiny === item.subTiny) {
-                        return;
-                    }
-                    if (crt) {
-                        crt.subTiny = item.subTiny;
-                    }
-                    else {
-                        crtSubList.push(item);
-                    }
-                    changed = true;
-                });
-                if (!changed && !forceReq) {
-                    engine.logger.warn(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
-                        status: RCLoggerStatus.FAILED,
-                        code: '',
-                        msg: 'repeat subscribe'
-                    }, {
-                        logSource: engine.LogSource.RTC
-                    });
-                    return { code: exports.RCRTCCode.SUCCESS };
-                }
-                // 北极星上报
-                store.polarisReport.sendR2(R2Action.SUBSCRIBE, R2Status.BEGIN, R2TrackIds);
-                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
-                    trackIds: tracks.map(getTrackIdFromAttr),
-                    roomId
-                }, {
-                    logSource: engine.LogSource.RTC
-                });
-                return new UpdateSubListCommand(crtSubList, this.subhook, true).execute(store, invoker);
-            });
-        }
-    }
-
     class ParseRemoteResCommand extends BaseCommand {
         constructor(msgContent, messageType, senderId, subhook, callback) {
             super();
@@ -11575,7 +11886,7 @@
                         const trackIds = subedTracks.map(item => item.getTrackId());
                         logger.debug(`resub tracks -> ${JSON.stringify(trackIds)}`);
                         // const { code } = await push(() => this.__subscribe(subedTracks, true))
-                        const { code } = yield new SubCommand(subedTracks, this.subhook, true).execute(store, invoker);
+                        const { code } = yield new UpdateSubscribeListCommand(subedTracks, this.subhook).execute(store, invoker);
                         if (code !== exports.RCRTCCode.SUCCESS) {
                             logger.error(`resub tracks failed -> code: ${code}, ids: ${JSON.stringify(trackIds)}`);
                         }
@@ -11631,15 +11942,101 @@
         }
     }
 
+    class SubscribeCommand extends BaseCommand {
+        constructor(tracks, subhook, forceReq) {
+            super();
+            this.tracks = tracks;
+            this.subhook = subhook;
+            this.forceReq = forceReq;
+        }
+        execute(store, invoker) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // 取消房间状态检查，房间销毁后，invoker 应直接清空，避免后续执行动作
+                // const roomStatusCode = this._assertRoomDestroyed()
+                // if (roomStatusCode) {
+                //   logger.error(`subscribe failed, room has been destroyed -> roomId: ${this._roomId}`)
+                //   return { code: RCRTCCode.ROOM_HAS_BEEN_DESTROYED }
+                // }
+                const { tracks, forceReq } = this;
+                const roomId = store.roomId;
+                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_T, {
+                    trackIds: tracks.map(getTrackIdFromAttr),
+                    forceReq
+                }, {
+                    logSource: engine.LogSource.RTC
+                });
+                if (!engine.validate('tracks', tracks, () => {
+                    return engine.isArray(tracks) && tracks.length > 0 && tracks.every(item => {
+                        return item instanceof RCRemoteTrack || item.track instanceof RCRemoteTrack;
+                    });
+                }, true)) {
+                    logger.warn(`subscribe failed, tracks is invalid -> roomId: ${roomId}`);
+                    engine.logger.error(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
+                        status: RCLoggerStatus.FAILED,
+                        code: exports.RCRTCCode.PARAMS_ERROR,
+                        msg: 'params error -> tracks'
+                    }, {
+                        logSource: engine.LogSource.RTC
+                    });
+                    return { code: exports.RCRTCCode.PARAMS_ERROR };
+                }
+                logger.info(`subscribe -> roomId: ${roomId}, tracks: ${tracks.map(getTrackIdFromAttr)}`);
+                const crtSubList = store.getSubscribedList().map(item => (Object.assign({}, item)));
+                const attrs = tracks.map(item => {
+                    return item instanceof RCRemoteTrack ? { track: item } : item;
+                });
+                let changed = false;
+                const R2TrackIds = [];
+                attrs.forEach(item => {
+                    const trackId = item.track.getTrackId();
+                    R2TrackIds.push(trackId);
+                    const crt = crtSubList.find(tmp => tmp.track.getTrackId() === trackId);
+                    if (crt && crt.subTiny === item.subTiny) {
+                        return;
+                    }
+                    if (crt) {
+                        crt.subTiny = item.subTiny;
+                    }
+                    else {
+                        crtSubList.push(item);
+                    }
+                    changed = true;
+                });
+                if (!changed && !forceReq) {
+                    engine.logger.warn(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
+                        status: RCLoggerStatus.FAILED,
+                        code: '',
+                        msg: 'repeat subscribe'
+                    }, {
+                        logSource: engine.LogSource.RTC
+                    });
+                    return { code: exports.RCRTCCode.SUCCESS };
+                }
+                // 北极星上报
+                store.polarisReport.sendR2(R2Action.SUBSCRIBE, R2Status.BEGIN, R2TrackIds);
+                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
+                    trackIds: tracks.map(getTrackIdFromAttr),
+                    roomId
+                }, {
+                    logSource: engine.LogSource.RTC
+                });
+                return new UpdateSubscribeListCommand(crtSubList, this.subhook, true).execute(store, invoker);
+            });
+        }
+    }
+
     /**
      * 资源发布命令
      */
-    class PubCommand extends BaseCommand {
+    class PublishCommand extends BaseCommand {
         constructor(tracks, pubhook) {
             super();
             this.tracks = tracks;
             this.pubhook = pubhook;
         }
+        get kind() {
+            return RCCommandKind.Publish;
+        }
         /**
          * 从 pc 移除当次发布失败的资源
          */
@@ -11703,7 +12100,6 @@
                 // 客户端主动调用 api 发请求时，清除 ice 断线重连的定时器
                 pc.clearReTryExchangeTimer();
                 // 发送 /exchange 请求
-                // const subscribeList = this._useMutilPeerC ? [] : this._subscribedList
                 const subscribeList = store.useMutilPeerC ? [] : store.getSubscribedList();
                 const reqBody = yield createExchangeParams(subscribeList, false, pc, store);
                 /**
@@ -11844,6 +12240,7 @@
                  */
                 const pubTasks = [];
                 const { plist, pushOtherRooms } = this.pubhook(tracks);
+                // 在不开启多 peerConnection 情况一下 plist = [ pc ]
                 for (let index = 0; index < plist.length; index++) {
                     const item = plist[index];
                     pubTasks.push(this.__publish(store, item, item.tracks, pushOtherRooms, invoker));
@@ -11862,12 +12259,15 @@
         }
     }
 
-    class UnpubCommand extends BaseCommand {
+    class UnpublishCommand extends BaseCommand {
         constructor(tracks, unpubhook) {
             super();
             this.tracks = tracks;
             this.unpubhook = unpubhook;
         }
+        get kind() {
+            return RCCommandKind.UnPublish;
+        }
         __unpublish(store, invoker, peerCItem, tracks) {
             return __awaiter(this, void 0, void 0, function* () {
                 const { pcName, pc } = peerCItem;
@@ -12311,6 +12711,260 @@
         }
     }
 
+    /**
+     * 更新订阅关系，为强制更新订阅关系，传入的 Tracks 都会被订阅
+     */
+    class AsyncUpdateSubscribeListCommand extends AsyncCommand {
+        constructor(tracks, subhook, callbacks, state = RCLinkedListPoint.NORMAL) {
+            super(state);
+            this.tracks = tracks;
+            this.subhook = subhook;
+            this.callbacks = callbacks;
+        }
+        execute(store, invoker) {
+            var _a, _b, _c;
+            return __awaiter(this, void 0, void 0, function* () {
+                const { tracks } = this;
+                const roomId = store.roomId;
+                logger.info(`unsubscribe -> roomId: ${roomId}, tracks: ${tracks.map(getTrackIdFromAttr)}`);
+                if (this.state === RCLinkedListPoint.NORMAL) {
+                    // 获取原订阅列表
+                    const originTracks = store.getSubscribedList().slice();
+                    const { code: updateSuscribeCode, failedList } = yield new UpdateSubscribeListCommand(tracks, this.subhook).execute(store, invoker);
+                    // 获取新的订阅列表
+                    const subscribedTracks = store.getSubscribedList().slice();
+                    // 计算订阅列表 Diff
+                    const { subscribe, unsubscribe } = this.pickoutSubscribed(subscribedTracks, originTracks);
+                    (_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onTaskCompleted({ code: updateSuscribeCode, subscribe, unsubscribe, failedList });
+                    return { code: updateSuscribeCode, failedList };
+                }
+                if (this.state === RCLinkedListPoint.TAIL) {
+                    // 自执行一次，计算出最终的 collectSubscribeList
+                    const { code: unsubscribeCode } = yield new AsyncUpdateSubscribeListCommand(this.tracks, this.subhook, this.callbacks, RCLinkedListPoint.MIDDLE).execute(store, invoker);
+                    // 拥塞队列处理完成的数据
+                    if (unsubscribeCode === exports.RCRTCCode.SUCCESS) {
+                        // 浅Copy 并对 store.getCollectSubscribeList 数据进行清空
+                        const tracks = store.getCollectSubscribeList().slice(0).map(item => item.track);
+                        const originTracks = store.getSubscribedList().slice();
+                        // 自执行一次，计算出最终的 collectSubscribeList
+                        const { code: updateSuscribeCode, failedList } = yield new UpdateSubscribeListCommand(tracks, this.subhook).execute(store, invoker);
+                        if (updateSuscribeCode !== exports.RCRTCCode.SUCCESS) {
+                            (_b = this.callbacks) === null || _b === void 0 ? void 0 : _b.onTaskCompleted({ code: updateSuscribeCode, subscribe: [], unsubscribe: [], failedList });
+                            return { code: updateSuscribeCode, failedList };
+                        }
+                        const subscribedTracks = store.getSubscribedList().slice(0);
+                        const { subscribe, unsubscribe } = this.pickoutSubscribed(subscribedTracks, originTracks);
+                        (_c = this.callbacks) === null || _c === void 0 ? void 0 : _c.onTaskCompleted({ code: updateSuscribeCode, subscribe, unsubscribe, failedList });
+                        return { code: updateSuscribeCode, failedList };
+                    }
+                    return { code: unsubscribeCode };
+                }
+                AsyncCommand.AsyncUpdateSubscribeTasks.splice(AsyncCommand.AsyncUpdateSubscribeTasks.length, 0, ...this.tracks);
+                // 处理队列中频繁调用，时带来的频繁订阅的逻辑 只处理一部分
+                return new Promise(resolve => {
+                    const formateTrack = tracks.map(item => {
+                        return item instanceof RCRemoteTrack ? { track: item } : item;
+                    });
+                    // 将需要订阅的数据 设置到订阅列表
+                    store.resetCollectSubscribeList(formateTrack);
+                    resolve({ code: exports.RCRTCCode.SUCCESS });
+                });
+            });
+        }
+    }
+
+    class AsyncSubscribeCommand extends AsyncCommand {
+        constructor(tracks, subhook, callbacks, state = RCLinkedListPoint.NORMAL) {
+            super(state);
+            this.tracks = tracks;
+            this.subhook = subhook;
+            this.callbacks = callbacks;
+        }
+        execute(store, invoker) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const { tracks } = this;
+                const roomId = store.roomId;
+                // 队列中只有一个发布或者取消发布任务，没有进行操作合并时的处理
+                if (this.state === RCLinkedListPoint.NORMAL) {
+                    // 获取原订阅列表
+                    const originTracks = store.getSubscribedList().slice();
+                    const { code: subscribeCode, failedList } = yield new SubscribeCommand(tracks, this.subhook).execute(store, invoker);
+                    // 获取新的订阅列表
+                    const subscribedTracks = store.getSubscribedList().slice();
+                    // 计算订阅列表 Diff
+                    const { subscribe, unsubscribe } = this.pickoutSubscribed(subscribedTracks, originTracks);
+                    (_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onTaskCompleted({ code: subscribeCode, subscribe, unsubscribe, failedList });
+                    return { code: subscribeCode, failedList };
+                }
+                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_T, {
+                    trackIds: tracks.map(getTrackIdFromAttr)
+                }, {
+                    logSource: engine.LogSource.RTC
+                });
+                if (!engine.validate('tracks', tracks, () => {
+                    return engine.isArray(tracks) && tracks.length > 0 && tracks.every(item => {
+                        return item instanceof RCRemoteTrack || item.track instanceof RCRemoteTrack;
+                    });
+                }, true)) {
+                    logger.warn(`subscribe failed, tracks is invalid -> roomId: ${roomId}`);
+                    engine.logger.error(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
+                        status: RCLoggerStatus.FAILED,
+                        code: exports.RCRTCCode.PARAMS_ERROR,
+                        msg: 'params error -> tracks'
+                    }, {
+                        logSource: engine.LogSource.RTC
+                    });
+                    return { code: exports.RCRTCCode.PARAMS_ERROR };
+                }
+                logger.info(`subscribe -> roomId: ${roomId}, tracks: ${tracks.map(getTrackIdFromAttr)}`);
+                const crtSubList = this.getSubscribedList(store).map(item => (Object.assign({}, item)));
+                const formateTrack = tracks.map(item => {
+                    return item instanceof RCRemoteTrack ? { track: item } : item;
+                });
+                const R2TrackIds = [];
+                // 查找所发布的 大流 是否存在及 小流 是否有变动
+                formateTrack.forEach(item => {
+                    const trackId = item.track.getTrackId();
+                    // 收集ID上报日志
+                    R2TrackIds.push(trackId);
+                    const crt = crtSubList.find(tmp => tmp.track.getTrackId() === trackId);
+                    if (crt) {
+                        if (crt.subTiny === item.subTiny) {
+                            return;
+                        }
+                        crt.subTiny = item.subTiny;
+                    }
+                    else {
+                        crtSubList.push(item);
+                    }
+                });
+                // 北极星上报
+                store.polarisReport.sendR2(R2Action.SUBSCRIBE, R2Status.BEGIN, R2TrackIds);
+                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_SUBSCRIBE_R, {
+                    trackIds: tracks.map(getTrackIdFromAttr),
+                    roomId
+                }, {
+                    logSource: engine.LogSource.RTC
+                });
+                if (this.state === RCLinkedListPoint.TAIL) {
+                    const { code: subscribeCode } = yield new AsyncSubscribeCommand(this.tracks, this.subhook, this.callbacks, RCLinkedListPoint.MIDDLE).execute(store, invoker);
+                    if (subscribeCode === exports.RCRTCCode.SUCCESS) {
+                        // 浅Copy 并对 store.getCollectSubscribeList 数据进行清空
+                        const tracks = store.getCollectSubscribeList().slice(0);
+                        return new AsyncUpdateSubscribeListCommand(tracks, this.subhook, this.callbacks).execute(store, invoker);
+                    }
+                    return { code: subscribeCode };
+                }
+                AsyncCommand.AsyncSubscribeTasks.splice(AsyncCommand.AsyncSubscribeTasks.length, 0, ...this.tracks);
+                // 处理队列中频繁调用，时带来的频繁订阅的逻辑 只处理一部分
+                return new Promise(resolve => {
+                    // 将数据写入到订阅列表中，最后一次变更（订阅|取消订阅）会再次处理它
+                    store.resetCollectSubscribeList(crtSubList);
+                    resolve({ code: exports.RCRTCCode.SUCCESS });
+                });
+            });
+        }
+        /**
+         * 如果当前节点的状态为 MIDDLE，则返回 store 的订阅属性列表。否则，返回存储的订阅属性列表
+         * @param {Store} store
+         * @returns ISubscribeAttr 对象的数组。
+         */
+        getSubscribedList(store) {
+            if (this.state === RCLinkedListPoint.MIDDLE) {
+                return store.getCollectSubscribeList();
+            }
+            return store.getSubscribedList();
+        }
+    }
+
+    class AsyncUnsubscribeCommand extends AsyncCommand {
+        constructor(tracks, subhook, callbacks, state = RCLinkedListPoint.NORMAL) {
+            super(state);
+            this.tracks = tracks;
+            this.subhook = subhook;
+            this.callbacks = callbacks;
+        }
+        execute(store, invoker) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const tracks = this.tracks;
+                const roomId = store.roomId;
+                // 队列中只有一个发布或者取消发布任务，没有进行操作合并时的处理
+                if (this.state === RCLinkedListPoint.NORMAL) {
+                    // 获取原订阅列表
+                    const originTracks = store.getSubscribedList().slice();
+                    const { code: unsubscribeCode, failedList } = yield new UnsubscribeCommand(tracks, this.subhook).execute(store, invoker);
+                    // 获取新的订阅列表
+                    const subscribedTracks = store.getSubscribedList().slice();
+                    // 计算出 Diff
+                    const { subscribe, unsubscribe } = this.pickoutSubscribed(subscribedTracks, originTracks);
+                    (_a = this.callbacks) === null || _a === void 0 ? void 0 : _a.onTaskCompleted({ code: unsubscribeCode, subscribe, unsubscribe, failedList });
+                    return { code: unsubscribeCode, failedList };
+                }
+                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_UNSUBSCRIBE_T, {
+                    trackIds: tracks.map(getTrackIdFromAttr)
+                }, {
+                    logSource: engine.LogSource.RTC
+                });
+                if (!engine.validate('tracks', tracks, () => {
+                    return engine.isArray(tracks) && tracks.length > 0 && tracks.every(item => item instanceof RCRemoteTrack);
+                }, true)) {
+                    logger.warn(`unsubscribe failed, tracks is invalid -> roomId: ${roomId}`);
+                    engine.logger.warn(RCLoggerTag.L_ABSTRACT_ROOM_UNSUBSCRIBE_R, {
+                        status: RCLoggerStatus.FAILED,
+                        code: exports.RCRTCCode.PARAMS_ERROR,
+                        msg: 'params error -> tracks'
+                    }, {
+                        logSource: engine.LogSource.RTC
+                    });
+                    return { code: exports.RCRTCCode.PARAMS_ERROR };
+                }
+                logger.info(`unsubscribe -> roomId: ${roomId}, tracks: ${tracks.map(getTrackIdFromAttr)}`);
+                // 计算剩余订阅列表, 如果资源在取消订阅列表内则排除它
+                const crtSubList = this.getSubscribedList(store).map(item => (Object.assign({}, item))).filter(item => !tracks.includes(item.track));
+                // 北极星上报
+                store.polarisReport.sendR2(R2Action.SUBSCRIBE, R2Status.END, tracks.map(item => item.getTrackId()));
+                engine.logger.info(RCLoggerTag.L_ABSTRACT_ROOM_UNSUBSCRIBE_R, {
+                    trackIds: tracks.map(getTrackIdFromAttr),
+                    roomId
+                }, {
+                    logSource: engine.LogSource.RTC
+                });
+                if (this.state === RCLinkedListPoint.TAIL) {
+                    // 自执行一次，计算出最终的 collectSubscribeList
+                    const { code: unsubscribeCode } = yield new AsyncUnsubscribeCommand(this.tracks, this.subhook, this.callbacks, RCLinkedListPoint.MIDDLE).execute(store, invoker);
+                    // 拥塞队列处理完成的数据
+                    if (unsubscribeCode === exports.RCRTCCode.SUCCESS) {
+                        // 浅Copy 并对 store.getCollectSubscribeList 数据进行清空
+                        const tracks = store.getCollectSubscribeList().slice(0).map(item => item.track);
+                        // 自执行一次，计算出最终的 collectSubscribeList
+                        return new AsyncUpdateSubscribeListCommand(tracks, this.subhook, this.callbacks).execute(store, invoker);
+                    }
+                    return { code: unsubscribeCode };
+                }
+                AsyncCommand.AsyncUnsubscribeTasks.splice(AsyncCommand.AsyncUnsubscribeTasks.length, 0, ...this.tracks);
+                // 处理队列中频繁调用，时带来的频繁订阅的逻辑 只处理一部分
+                return new Promise(resolve => {
+                    // 将需要订阅的数据 设置到订阅列表
+                    store.resetCollectSubscribeList(crtSubList);
+                    resolve({ code: exports.RCRTCCode.SUCCESS });
+                });
+            });
+        }
+        /**
+         * 如果当前节点的状态为 MIDDLE，则返回 store 的订阅属性列表。否则，返回存储的订阅属性列表
+         * @param {Store} store
+         * @returns ISubscribeAttr 对象的数组。
+         */
+        getSubscribedList(store) {
+            if (this.state === RCLinkedListPoint.MIDDLE) {
+                return store.getCollectSubscribeList();
+            }
+            return store.getSubscribedList();
+        }
+    }
+
     const RCAbstractRoomEvent = {
         LEAVE: 'evt-leave'
     };
@@ -12474,7 +13128,7 @@
                     // TODO 处理加入的 PK 房间断线情况
                     break;
                 default:
-                    this._callAppListener('onMessageReceive', message.messageType, message.content, message.senderUserId, message.messageUId);
+                    this._callAppListener('onMessageReceive', message.messageType, content, message.senderUserId, message.messageUId);
                     break;
             }
             return true;
@@ -12876,7 +13530,7 @@
          */
         publish(tracks) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._invoker.push(new PubCommand(tracks, this._pubhook.bind(this)));
+                return this._invoker.push(new PublishCommand(tracks, this._pubhook.bind(this)));
             });
         }
         /**
@@ -12913,7 +13567,7 @@
          */
         unpublish(tracks) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._invoker.push(new UnpubCommand(tracks, (tracks, pcName) => {
+                return this._invoker.push(new UnpublishCommand(tracks, (tracks, pcName) => {
                     return { pushOtherRooms: this._getPushOtherRoomsParams(), headers: this._getRTCReqestHeaders(pcName) };
                 }));
             });
@@ -12967,18 +13621,60 @@
          */
         subscribe(tracks) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._invoker.push(new SubCommand(tracks, this._subhook.bind(this), false));
+                return this._invoker.push(new SubscribeCommand(tracks, this._subhook.bind(this)));
             });
         }
+        /**
+         * 它将订阅任务添加到队列中。
+         * @param {(RCRemoteTrack | ISubscribeAttr)[]} tracks - (RCRemoteTrack | ISubscribeAttr)[]
+         * @returns 一个用代码和失败列表解析为对象的承诺。
+         */
+        addSubscribeTask(tracks) {
+            this._invoker.push(new AsyncSubscribeCommand(tracks, this._subhook.bind(this), {
+                onTaskCompleted: this._onTaskCompleted.bind(this)
+            }));
+        }
         /**
          * 取消订阅资源
          * @param tracks 预取消远端资源
          */
         unsubscribe(tracks) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._invoker.push(new UnsubCommand(tracks, this._subhook.bind(this)));
+                return this._invoker.push(new UnsubscribeCommand(tracks, this._subhook.bind(this)));
             });
         }
+        /**
+         * 它将取消订阅任务添加到队列中。
+         * @param {RCRemoteTrack[]} tracks - 要取消订阅的曲目。
+         * @returns 一个用代码和失败列表解析为对象的承诺。
+         */
+        addUnsubscribeTask(tracks) {
+            this._invoker.push(new AsyncUnsubscribeCommand(tracks, this._subhook.bind(this), {
+                onTaskCompleted: this._onTaskCompleted.bind(this)
+            }));
+        }
+        /**
+         * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
+         * 当参数为 `[]` 时，意味着不再订阅任何资源
+         * @param tracks 变更的资源列表
+         */
+        updateSubList(tracks) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this._invoker.push(new UpdateSubscribeListCommand(tracks, this._subhook.bind(this)));
+            });
+        }
+        /**
+         * 将任务添加到任务队列的函数。
+         * @param {(RCRemoteTrack | ISubscribeAttr)[]} tracks - (RCRemoteTrack | ISubscribeAttr)[]
+         */
+        addUpdateSubscribeListTask(tracks) {
+            this._invoker.push(new AsyncUpdateSubscribeListCommand(tracks, this._subhook.bind(this), {
+                onTaskCompleted: this._onTaskCompleted.bind(this)
+            }));
+        }
+        _onTaskCompleted(content) {
+            this._callAppListener('onTaskCompleted', content.code, content.subscribe, content.unsubscribe, content.failedList);
+        }
         /**
          * 获取已发布的本地资源
          * @param trackId
@@ -13002,15 +13698,12 @@
             return this._store.getRemoteTrack(trackId) || null;
         }
         /**
-         * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
-         * 当参数为 `[]` 时，意味着不再订阅任何资源
-         * @param tracks 变更的资源列表
+         * 获取当前已经订阅的全量资源
+         * returns subscribedTracks ISubscribeAttr[]
          */
-        updateSubList(tracks) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // return push(() => this._updateSubListHandle(tracks, false))
-                return this._invoker.push(new UpdateSubListCommand(tracks, this._subhook.bind(this), false));
-            });
+        get subscribedTracks() {
+            // 浅Copy 获取已经订阅的列表
+            return this._store.getSubscribedList().slice();
         }
         /**
          * 注册事件监听器，多次注册会导致后者覆盖前者，可以通过使用 `registerRoomEventListener(null)` 取消注册
@@ -14427,6 +15120,9 @@
             this._joinedPKRooms = _joinedPKRooms;
             this.isQuitPK = isQuitPK;
         }
+        get kind() {
+            return RCCommandKind.LeaveRoom;
+        }
         /**
        * 结束跨房间连麦
        * @param roomId 需要结束连麦的房间 roomId
@@ -15142,7 +15838,7 @@
                  * 需先清除房间内的己方资源，通知房间内其他人己方已取消当前资源的发布
                  * 该步骤没有必要与 MediaServer 的交互，因后续资源变更交互为全量交互
                  */
-                selfRes.length > 0 && invoker.push(new UnpubPrevCommand());
+                selfRes.length > 0 && invoker.push(new UnpublishPrevCommand());
                 const CDNUris = (_a = data.roomInfo.filter((item) => { return item.key === 'cdn_uris'; })[0]) === null || _a === void 0 ? void 0 : _a.value;
                 CDNUris && store.setCDNUris(JSON.parse(CDNUris)[0]);
                 return { code, data };
@@ -16726,6 +17422,12 @@
                 return push(() => this._subscribeHandle(tracks, false), 'audience-sub');
             });
         }
+        addSubscribeTask(tracks) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // TODO: 重构RCAudienceLivingRoom, 使用队列处理
+                return push(() => this._subscribeHandle(tracks, false), 'audience-sub');
+            });
+        }
         __unsubscribe(tracks) {
             var _a;
             return __awaiter(this, void 0, void 0, function* () {
@@ -16774,6 +17476,12 @@
                 return push(() => this.__unsubscribe(tracks), 'audience-unsub');
             });
         }
+        addUnsubscribeTask(tracks) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // TODO: 重构RCAudienceLivingRoom, 使用队列处理
+                return push(() => this.__unsubscribe(tracks), 'audience-unsub');
+            });
+        }
         /**
          * 退出房间并销毁当前房间实例，退出后该房间的所有方法将不可用
          */
@@ -16983,7 +17691,10 @@
                 }
                 catch (error) {
                     if (error.message === 'Permission denied') {
-                        return { code: exports.RCRTCCode.PERMISSION_DENIED };
+                        return { code: exports.RCRTCCode.BROWSER_PERMISSION_DENIED };
+                    }
+                    if (error.message === 'Permission denied by system') {
+                        return { code: exports.RCRTCCode.SYSTEM_PERMISSION_DENIED };
                     }
                     logger.error(`get user media failed -> ${error.message}`);
                 }
@@ -18192,7 +18903,7 @@
                 logger.error('Please use the https protocol or use `http://localhost` to open the page!');
                 return false;
             }
-            engine.VersionManage.add('plugin-rtc', "5.4.4-alpha.1");
+            engine.VersionManage.add('plugin-rtc', "5.4.5-alpha.1");
             if (!engine.VersionManage.validEngine(">=5.3.3-beem-alpha.2 || >=5.3.4")) {
                 logger.error(`The current engine version '${engine.VersionManage.getInfo().engine}' error, plugin-rtc required engine version at least '${">=5.3.3-beem-alpha.2 || >=5.3.4"}'.`);
                 return false;
@@ -18200,9 +18911,10 @@
             return true;
         },
         setup(context, runtime, options = {}) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
             logger.setLogLevel(options.logLevel);
             logger.setLogStdout(options.logStdout);
-            logger.warn(`RCRTC Version: ${"5.4.4-alpha.1"}, Commit: ${"62dca5e7f4d904aeefb9634071be2b9b2f37c61d"}`);
+            logger.warn(`RCRTC Version: ${"5.4.5-alpha.1"}, Commit: ${"960e964ebd4294c2f095e87cf9e33935703b475e"}`);
             logger.warn(`browserInfo.browser -> ${browserInfo.browser}`);
             logger.warn(`browserInfo.supportsUnifiedPlan -> ${browserInfo.supportsUnifiedPlan}`);
             logger.warn(`browserInfo.version -> ${browserInfo.version}`);
@@ -18218,6 +18930,21 @@
             engine.assert('options.pingGap', options.pingGap, (value) => {
                 return engine.isNumber(value) && value >= 3000 && value <= 10000;
             });
+            if (options === null || options === void 0 ? void 0 : options.audio) {
+                if ((_a = options.audio) === null || _a === void 0 ? void 0 : _a.workletModule) {
+                    RC3AnoiseTrack.workletModule = (_b = options.audio) === null || _b === void 0 ? void 0 : _b.workletModule;
+                }
+                if ((_c = options.audio) === null || _c === void 0 ? void 0 : _c.workletWasm) {
+                    RC3AnoiseTrack.workletWasm = (_d = options.audio) === null || _d === void 0 ? void 0 : _d.workletWasm;
+                }
+                /* 如果 workletModule 与 workletWasm 都配置了，则将 isOpen 配置为 true */
+                if (((_e = options.audio) === null || _e === void 0 ? void 0 : _e.workletModule) && ((_f = options.audio) === null || _f === void 0 ? void 0 : _f.workletWasm)) {
+                    RC3AnoiseTrack.isOpen = true;
+                }
+                if (typeof ((_g = options.audio) === null || _g === void 0 ? void 0 : _g.isOpen) !== 'undefined') {
+                    RC3AnoiseTrack.isOpen = (_h = options.audio) === null || _h === void 0 ? void 0 : _h.isOpen;
+                }
+            }
             return new RCRTCClient(context, runtime, options);
         }
     };