@rongcloud/plugin-rtc 5.3.0-rtc-roompk.1 → 5.3.2-alpha.1

package/dist/index.umd.js

@@ -1,7 +1,7 @@
 /*
- * RCRTC - v5.3.0-rtc-roompk.1
- * CommitId - 381b45b74bd1cee88cf1e6e79108809734bb17ea
- * Sat Dec 25 2021 01:21:26 GMT+0800 (China Standard Time)
+ * RCRTC - v5.3.2-alpha.1
+ * CommitId - db999e233480c8537357ef17495b0bbb67c692fe
+ * Mon Feb 14 2022 20:24:02 GMT+0800 (China Standard Time)
  * ©2020 RongCloud, Inc. All rights reserved.
  */
 (function (global, factory) {
@@ -6432,12 +6432,21 @@
     /**
      * 解析房间数据
      */
-    const parseRoomData = (data) => {
+    const parseRoomData = (data, mainRoomId) => {
         const result = {};
         const userIds = Object.keys(data.users);
         userIds.length && userIds.forEach(userId => {
             const tmp = [];
             const userData = data.users[userId];
+            /**
+             * 过滤掉副房间身份的人员
+             */
+            if (userData.extra) {
+                const roomId = JSON.parse(userData.extra).roomId;
+                if (mainRoomId !== roomId) {
+                    return;
+                }
+            }
             if (userData.uris) {
                 try {
                     tmp.push(...JSON.parse(userData.uris));
@@ -6450,16 +6459,31 @@
         });
         return result;
     };
+    /**
+     * 从加房间返回的数据中获取加入的副房间
+     */
+    const getPKInfoByRoomData = (mainRoomId, roomInfo) => {
+        const pkInfo = {};
+        roomInfo.forEach((item) => {
+            const PKValue = JSON.parse(item.value);
+            const { inviterRoomId, inviteeRoomId } = PKValue;
+            const roomId = (mainRoomId === inviterRoomId) ? inviteeRoomId : inviterRoomId;
+            pkInfo[roomId] = JSON.parse(item.value);
+        });
+        return pkInfo;
+    };
     /**
      * 解析观众加房间 kv 数据
      * 远端无人员时，kvEntries 的 key 不包含 RC_ANCHOR_LIST
      * 远端无资源时，key 不包含 RC_RES_、RC_CDN
      * 远端有资源、无 CDN 资源时，key 不包含 RC_CDN
+     * 服务端 bug，偶现无 RC_RTC_SESSIONID
      */
     const parseAudienceRoomData = (roomId, kvEntries) => {
-        const sessionId = kvEntries.filter((kvItem) => {
+        const session = kvEntries.filter((kvItem) => {
             return kvItem.key === 'RC_RTC_SESSIONID';
-        })[0].value;
+        })[0];
+        const sessionId = session ? session.value : '';
         /**
          * 房间内远端人员
          */
@@ -8462,7 +8486,7 @@
          * 加入房间
          */
         sendR1() {
-            const rtcVersion = "5.3.0-rtc-roompk.1";
+            const rtcVersion = "5.3.2-alpha.1";
             const imVersion = this._context.getCoreVersion();
             const platform = 'web';
             const pcName = navigator.platform;
@@ -8610,6 +8634,9 @@
             // 资源、人员变更消息需按队列逐个处理，确保内存状态不乱
             this.msgTaskQueue = new AsyncTaskQueue();
             this._appListener = null;
+            /**
+             * 存储连麦监听事件
+             */
             this._onRecvPKMsg = null;
             this._token = data.token;
             this._sessionId = data.sessionId;
@@ -8622,7 +8649,7 @@
                 this._roomResources = {};
             }
             else {
-                this._roomResources = parseRoomData(data);
+                this._roomResources = parseRoomData(data, this._roomId);
             }
             // 根据解析出来的数据构建远端流
             this._initRemoteTracks();
@@ -8833,7 +8860,8 @@
                     return;
                 }
                 const { uris, ignore } = content;
-                if (ignore) {
+                // 内置 CDN 为自动时，先收到 cdn_uris，无 uris 时，不用再对比资源
+                if (ignore || !uris) {
                     return;
                 }
                 const publishedList = [];
@@ -8944,6 +8972,20 @@
                 if (users.length === 0) {
                     return;
                 }
+                /**
+                 * 过滤掉副房间身份的人员
+                 */
+                for (let index = 0; index < users.length; index++) {
+                    const user = users[index];
+                    // 加入房间时
+                    if (user.extra && user.extra.roomId !== this._roomId) {
+                        return;
+                    }
+                    // 退出房间时
+                    if (+user.state === 1 && !this.getRemoteUserIds().includes(user.userId)) {
+                        return;
+                    }
+                }
                 /**
                  * 主动加入房间
                  */
@@ -9187,14 +9229,14 @@
                 if (quitRoom) {
                     // 退出 signal 房间
                     yield this._context.quitRTCRoom(this._roomId);
-                    // 退出主房间时，退出所有 PK 房间
-                    this._isMainRoom && this._quitPKRoom();
                 }
+                // 退出主房间时，退出所有 PK 房间
+                this._isMainRoom && this._quitAllPKRoom();
                 this._pc.removeAllLocalTrack();
                 // 停止 rtcPing 计时
                 this._pinger.stop();
-                // 中断与 MediaServer 的 UDP 连接
-                yield this._service.exit(this._getRTCReqestHeaders());
+                // 退出主房间时，中断与 MediaServer 的 UDP 连接
+                this._isMainRoom && (yield this._service.exit(this._getRTCReqestHeaders()));
                 // 销毁 pc 连接
                 this._pc.destroy();
                 // 销毁 polarisReport 实例
@@ -9271,6 +9313,10 @@
         }
         __publish(tracks) {
             return __awaiter(this, void 0, void 0, function* () {
+                if (!this._isMainRoom && (this instanceof RCLivingRoom)) {
+                    logger.error('the `publish` is disabled in PK room ');
+                    return { code: exports.RCRTCCode.THE_FUNCTION_IS_DISABLED_IN_PKROOM };
+                }
                 const roomStatusCode = this._assertRoomDestroyed();
                 if (roomStatusCode) {
                     logger.error(`publish failed, room has been destroyed. -> roomId: ${this._roomId}`);
@@ -9325,23 +9371,8 @@
                 /**
                  * 直播房间需携带 pushOtherRooms 信息
                  */
-                if (this instanceof RCLivingRoom) {
-                    const { code, roomPKHandler } = this.getRoomPKHandler();
-                    if (code === exports.RCRTCCode.SUCCESS && roomPKHandler) {
-                        const joinedPKRooms = roomPKHandler.getJoinedPKRooms();
-                        reqBody.pushOtherRooms = [];
-                        for (const roomId in joinedPKRooms) {
-                            const room = joinedPKRooms[roomId];
-                            const sessionId = room.getSessionId();
-                            const { inviterUserAutoMix: autoMix } = roomPKHandler.getPKInfo(roomId);
-                            reqBody.pushOtherRooms.push({
-                                roomId,
-                                sessionId,
-                                autoMix: autoMix
-                            });
-                        }
-                    }
-                }
+                const pushOtherRooms = this._getPushOtherRoomsParams();
+                pushOtherRooms && (reqBody.pushOtherRooms = pushOtherRooms);
                 const resp = yield this._exchangeHandle(reqBody);
                 if (resp.code !== exports.RCRTCCode.SUCCESS) {
                     // TODO: 资源发送失败，需要移除已添加至 RTCPeerConnection 中的资源信息
@@ -9396,6 +9427,37 @@
                 return { code: exports.RCRTCCode.SUCCESS };
             });
         }
+        /**
+         * 获取跨房间连麦需携带参数 pushOtherRooms 的值
+         */
+        _getPushOtherRoomsParams() {
+            if (this instanceof RCLivingRoom) {
+                const { code, roomPKHandler } = this.getRoomPKHandler();
+                const pushOtherRooms = [];
+                if (code === exports.RCRTCCode.SUCCESS && roomPKHandler) {
+                    const joinedPKRooms = roomPKHandler.getJoinedPKRooms();
+                    for (const roomId in joinedPKRooms) {
+                        const room = joinedPKRooms[roomId];
+                        const sessionId = room.getSessionId();
+                        /**
+                         * 直接加入 PK 房间，无连麦关系时，无 PKInfo 信息
+                         */
+                        const PKInfo = roomPKHandler.getPKInfo(roomId);
+                        if (!PKInfo) {
+                            return;
+                        }
+                        const { inviterUserAutoMix, inviteeUserAutoMix, inviterUserId } = PKInfo;
+                        const isInviter = (this._context.getCurrentId() === inviterUserId);
+                        pushOtherRooms.push({
+                            roomId,
+                            sessionId,
+                            autoMix: isInviter ? !!inviterUserAutoMix : !!inviteeUserAutoMix
+                        });
+                    }
+                }
+                return pushOtherRooms;
+            }
+        }
         /**
          * ice 断线后，尝试重新走 exchange
          */
@@ -9403,6 +9465,11 @@
             return __awaiter(this, void 0, void 0, function* () {
                 push(() => __awaiter(this, void 0, void 0, function* () {
                     const reqBody = yield this._createExchangeParams(this._subscribedList, true);
+                    /**
+                     * 直播房间需携带 pushOtherRooms 信息
+                     */
+                    const pushOtherRooms = this._getPushOtherRoomsParams();
+                    pushOtherRooms && (reqBody.pushOtherRooms = pushOtherRooms);
                     // 发送 /exchange 请求
                     const resp = yield this._exchangeHandle(reqBody);
                     if (resp.code !== exports.RCRTCCode.SUCCESS) {
@@ -9487,6 +9554,10 @@
         __unpublish(tracks) {
             var _a;
             return __awaiter(this, void 0, void 0, function* () {
+                if (!this._isMainRoom && (this instanceof RCLivingRoom)) {
+                    logger.error('the `unpublish` is disabled in PK room ');
+                    return { code: exports.RCRTCCode.THE_FUNCTION_IS_DISABLED_IN_PKROOM };
+                }
                 const roomStatusCode = this._assertRoomDestroyed();
                 if (roomStatusCode) {
                     logger.warn(`room has been destroyed, no need to unpublish tracks -> roomId: ${this._roomId}`);
@@ -9517,6 +9588,11 @@
                 // 客户端主动调用 api 发请求时，清除 ice 断线重连的定时器
                 this._pc.clearReTryExchangeTimer();
                 const reqBody = yield this._createExchangeParams(this._subscribedList, false);
+                /**
+                 * 直播房间需携带 pushOtherRooms 信息
+                 */
+                const pushOtherRooms = this._getPushOtherRoomsParams();
+                pushOtherRooms && (reqBody.pushOtherRooms = pushOtherRooms);
                 const result = yield this._exchangeHandle(reqBody);
                 if (result.code !== exports.RCRTCCode.SUCCESS) {
                     logger.error(`exchange failed -> code: ${result.code}`);
@@ -9750,6 +9826,11 @@
                 this._pc.clearReTryExchangeTimer();
                 this._pc.updateSubRemoteTracks(attrs.map(item => item.track));
                 const reqBody = yield this._createExchangeParams(attrs, false);
+                /**
+                 * 直播房间需携带 pushOtherRooms 信息
+                 */
+                const pushOtherRooms = this._getPushOtherRoomsParams();
+                pushOtherRooms && (reqBody.pushOtherRooms = pushOtherRooms);
                 const result = yield this._exchangeHandle(reqBody);
                 const subTrackIds = attrs.map((item) => { return item.track.getTrackId(); });
                 if (result.code !== exports.RCRTCCode.SUCCESS) {
@@ -9835,7 +9916,7 @@
                 // 状态变更的资源
                 const modified = {};
                 // 当前最新的房间资源数据
-                const roomData = parseRoomData(data);
+                const roomData = parseRoomData(data, this._roomId);
                 const nowUserIds = Object.keys(roomData);
                 const prevUserIds = Object.keys(this._roomResources);
                 for (let i = nowUserIds.length - 1; i >= 0; i -= 1) {
@@ -9940,7 +10021,7 @@
         /**
          * 退出 PK 房间
          */
-        _quitPKRoom() { }
+        _quitAllPKRoom() { }
     }
 
     /**
@@ -10496,7 +10577,7 @@
     };
 
     class RCLivingPKHandler {
-        constructor(_context, _runtime, _service, _initOptions, 
+        constructor(_PKInfo, _context, _runtime, _service, _initOptions, 
         /**
          * 主直播房间
          */
@@ -10509,6 +10590,7 @@
          * 退出 PK 房间回调
          */
         _onLeavePKRoom) {
+            this._PKInfo = _PKInfo;
             this._context = _context;
             this._runtime = _runtime;
             this._service = _service;
@@ -10518,13 +10600,13 @@
             this._onJoinedPKRoom = _onJoinedPKRoom;
             this._onLeavePKRoom = _onLeavePKRoom;
             /**
-             * PK 邀请超时时间
+             * PK 邀请超时时间，默认 30s
              */
-            this._inviteTimeout = 30 * 1000;
+            this._inviteTimeout = 30;
             /**
              * PK 房间信息
              */
-            this._PKInfo = {};
+            // private _PKInfo: IPKInfo = {}
             this._appListener = null;
             /**
              * 跨房间连麦加入的 PK 房间
@@ -10546,6 +10628,9 @@
                 logger.error(error);
             }
         }
+        /**
+         * 收到连麦邀请
+         */
         _onInvite(content) {
             const inviteInfo = (content.inviteInfo || {});
             const { inviterRoomId, inviterUserId, extra } = inviteInfo;
@@ -10557,6 +10642,9 @@
             this._PKInfo[inviterRoomId] = inviteInfo;
             this._callAppListener('onRequestJoinOtherRoom', info);
         }
+        /**
+         * 收到取消连麦
+         */
         _onCancelInvite(content) {
             const { inviterRoomId, inviterUserId, extra } = (content.inviteInfo || {});
             const cancelInfo = {
@@ -10570,9 +10658,12 @@
         _onInviteTimeout(content) {
             // 因服务计时不准，暂不处理。（与移动端一致）
         }
+        /**
+         * 收到响应连麦
+         */
         _onInviteAnswer(content) {
-            const { answerCode, inviteSessionId, inviteContent, inviteeUserAutoMix } = content;
-            const { inviterUserId, inviterRoomId, inviteeUserId, inviteeRoomId, extra } = inviteContent;
+            const { answerCode, inviteContent } = content;
+            const { inviteSessionId, inviterUserId, inviterRoomId, inviteeUserId, inviterUserAutoMix, inviteeUserAutoMix, inviteeRoomId, extra } = inviteContent;
             const answerInfo = {
                 agree: answerCode === 1,
                 inviterRoomId,
@@ -10580,19 +10671,35 @@
                 inviteeRoomId,
                 inviteeUserId
             };
+            /**
+             * 收到非本人发起的邀请连麦时，需新组装 PKInfo
+             */
+            this._PKInfo[inviteeRoomId] = this._PKInfo[inviteeRoomId] || {
+                inviteSessionId,
+                inviterRoomId,
+                inviterUserId,
+                inviterUserAutoMix,
+                inviteeRoomId
+            };
             this._PKInfo[inviteeRoomId].inviteeUserAutoMix = inviteeUserAutoMix;
             this._callAppListener('onResponseJoinOtherRoom', answerInfo);
         }
+        /**
+         * 收到连麦结束
+         */
         _onPKEnd(content) {
-            const { inviteeRoomId, inviterRoomId, userId } = content.inviteInfo;
-            const endInfo = {
-                endRoomId: inviteeRoomId,
-                endUserId: userId
-            };
-            const roomId = inviterRoomId === this._mainRoomId ? inviteeRoomId : inviterRoomId;
-            this.leaveOtherRoom(this._joinedPKRooms[roomId]);
-            delete this._PKInfo[roomId];
-            this._callAppListener('onFinishOtherRoom', endInfo);
+            return __awaiter(this, void 0, void 0, function* () {
+                const { inviteeRoomId, inviterRoomId, userId } = content.inviteInfo;
+                const roomId = inviterRoomId === this._mainRoomId ? inviteeRoomId : inviterRoomId;
+                const endInfo = {
+                    endRoomId: roomId,
+                    endUserId: userId
+                };
+                // 兼容先退出房间，再收到 pk 结束的情况
+                this._joinedPKRooms[roomId] && (yield this.leaveOtherRoom(this._joinedPKRooms[roomId]));
+                delete this._PKInfo[roomId];
+                this._callAppListener('onFinishOtherRoom', endInfo);
+            });
         }
         /**
          * 处理跨房间连麦相关消息
@@ -10618,17 +10725,17 @@
             }
         }
         /**
-         * 跨房间连麦 PK 事件注册
+         * 注册跨房间连麦监听事件
          */
         registerRoomPKEventListener(listener) {
             this._appListener = listener;
         }
         /**
          * 发起跨房间连麦请求
-         * @param inviteeRoomId 被邀请者所处的房间 ID
-         * @param inviteeUserId 被邀请者 ID
-         * @param options.autoMix 被邀请者的发布的资源在服务侧是否自动合流
-         * @param options.extra 拓展字段，用于邀请数据透传
+         * @param inviteeRoomId 被邀请者所处的房间 roomId
+         * @param inviteeUserId 被邀请者 userId
+         * @param options.autoMix 是否要把邀请者发布的资源，合并到被邀请者房间内的 MCU 流中
+         * @param options.extra 拓展字段，可随邀请连麦消息透传给被邀请者
          */
         requestJoinOtherRoom(inviteeRoomId, inviteeUserId, options) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -10639,13 +10746,6 @@
                 logger.debug(`requestRoomPK -> inviteeRoomId: ${inviteeRoomId}; inviteeUserId: ${inviteeUserId}; options: ${JSON.stringify(options || {})}`);
                 const inviteSessionId = getUUID();
                 const autoMix = engine.isBoolean(options === null || options === void 0 ? void 0 : options.autoMix) ? options === null || options === void 0 ? void 0 : options.autoMix : true;
-                this._PKInfo[inviteeRoomId] = {
-                    inviteSessionId,
-                    inviterRoomId: this._mainRoomId,
-                    inviterUserId: this._context.getCurrentId(),
-                    inviterUserAutoMix: autoMix,
-                    inviteeRoomId
-                };
                 const inviteInfo = {
                     inviteSessionId,
                     inviterRoomId: this._mainRoomId,
@@ -10668,13 +10768,24 @@
                 const code = yield this._context.requestRoomPK(params);
                 if (code !== engine.ErrorCode.SUCCESS) {
                     logger.error(`requestRoomPK failed: ${code}`);
-                    return { code: exports.RCRTCCode.SIGNAL_ERROR };
+                    return { code };
                 }
+                logger.debug('requestRoomPK success');
+                this._PKInfo[inviteeRoomId] = {
+                    inviteSessionId,
+                    inviterRoomId: this._mainRoomId,
+                    inviterUserId: this._context.getCurrentId(),
+                    inviterUserAutoMix: autoMix,
+                    inviteeRoomId
+                };
                 return { code: exports.RCRTCCode.SUCCESS };
             });
         }
         /**
-         * 取消跨房间连麦 PK 请求
+         * 取消跨房间连麦请求
+         * @param inviteeRoomId 被邀请者所处的房间 roomId
+         * @param inviteeUserId 被邀请者 userId
+         * @param extra 附加信息，可随取消邀请连麦消息透传给被邀请者
          */
         cancelRequestJoinOtherRoom(inviteeRoomId, inviteeUserId, extra) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -10682,6 +10793,10 @@
                     engine.validate('inviteeUserId', inviteeUserId, engine.notEmptyString, true))) {
                     return { code: exports.RCRTCCode.PARAMS_ERROR };
                 }
+                if (!this._PKInfo[inviteeRoomId]) {
+                    logger.error(`未发起过与 ${inviteeRoomId} 房间内 ${inviteeUserId} 连麦的请求`);
+                    return { code: exports.RCRTCCode.PARAMS_ERROR };
+                }
                 logger.debug(`canceRequestJoinPK -> inviteeRoomId: ${inviteeRoomId}; inviteeUserId: ${inviteeUserId}; extra: ${extra}`);
                 const inviteInfo = {
                     inviterRoomId: this._mainRoomId,
@@ -10701,13 +10816,20 @@
                 const code = yield this._context.cancelRoomPK(params);
                 if (code !== engine.ErrorCode.SUCCESS) {
                     logger.error(`canceRequestJoinPK failed: ${code}`);
-                    return { code: exports.RCRTCCode.SIGNAL_ERROR };
+                    return { code };
                 }
+                logger.debug('canceRequestJoinPK success');
+                delete this._PKInfo[inviteeRoomId];
                 return { code: exports.RCRTCCode.SUCCESS };
             });
         }
         /**
-         * 跨房间连麦 PK 响应
+         * 响应跨房间连麦请求
+         * @param inviterRoomId 邀请者所处的房间 roomId
+         * @param inviterUserId 邀请者 userId
+         * @param agree 是否同意连麦
+         * @param options.autoMix 是否要把被邀请者发布的资源，合并到邀请者房间内的 MCU 流中
+         * @param options.extra 附加信息，可随响应连麦消息透传给邀请者
          */
         responseJoinOtherRoom(inviterRoomId, inviterUserId, agree, options) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -10715,6 +10837,10 @@
                     engine.validate('inviterUserId', inviterUserId, engine.notEmptyString, true))) {
                     return { code: exports.RCRTCCode.PARAMS_ERROR };
                 }
+                if (!this._PKInfo[inviterRoomId]) {
+                    logger.error(`${inviterRoomId} 房间内的 ${inviterUserId} 未发起过连麦请求`);
+                    return { code: exports.RCRTCCode.PARAMS_ERROR };
+                }
                 logger.debug(`responseRoomPK -> inviterRoomId: ${inviterRoomId}; inviterUserId: ${inviterUserId}; agree: ${agree}; options: ${JSON.stringify(options || {})}`);
                 const { inviteSessionId, inviterUserAutoMix } = this._PKInfo[inviterRoomId];
                 const autoMix = engine.isBoolean(options === null || options === void 0 ? void 0 : options.autoMix) ? options === null || options === void 0 ? void 0 : options.autoMix : true;
@@ -10722,6 +10848,7 @@
                     inviteSessionId,
                     inviterRoomId,
                     inviterUserId,
+                    inviterUserAutoMix,
                     inviteeRoomId: this._mainRoomId,
                     inviteeUserId: this._context.getCurrentId(),
                     inviteeUserAutoMix: autoMix
@@ -10739,28 +10866,26 @@
                     inviteRoomId: inviterRoomId,
                     inviteUserId: inviterUserId,
                     content: JSON.stringify(content),
-                    key: `${inviterRoomId}|${inviterUserId}`,
+                    key: `${inviterRoomId}|${this._mainRoomId}`,
                     value: JSON.stringify(value)
                 };
                 logger.debug(`responseRoomPK -> params: ${JSON.stringify(params)}`);
                 const code = yield this._context.responseRoomPK(params);
                 if (code !== engine.ErrorCode.SUCCESS) {
                     logger.error(`responseRoomPK failed: ${code}`);
-                    return { code: exports.RCRTCCode.SIGNAL_ERROR };
+                    return { code };
                 }
+                logger.debug('responseRoomPK success');
+                this._PKInfo[inviterRoomId].inviteeUserAutoMix = autoMix;
                 return { code: exports.RCRTCCode.SUCCESS };
             });
         }
         /**
-         * 结束跨房间连麦 PK
-         * @param roomId 需要退出 PK 的房间 ID
+         * 结束跨房间连麦
+         * @param roomId 需要结束连麦的房间 roomId
          */
         _quitRoomPK(roomId) {
             return __awaiter(this, void 0, void 0, function* () {
-                if (!(engine.validate('roomId', roomId, engine.notEmptyString, true))) {
-                    return { code: exports.RCRTCCode.PARAMS_ERROR };
-                }
-                logger.debug(`quitRoomPK -> roomId: ${roomId}`);
                 const { inviterRoomId, inviteeRoomId, inviterUserId } = this._PKInfo[roomId];
                 const content = {
                     inviteeRoomId,
@@ -10780,13 +10905,15 @@
                     logger.error(`quitRoomPK failed: ${code}`);
                     return { code: exports.RCRTCCode.SIGNAL_ERROR };
                 }
+                logger.debug('quitRoomPK success');
+                delete this._PKInfo[roomId];
                 return { code: exports.RCRTCCode.SUCCESS };
             });
         }
         _relaseCrtRoom() { }
         /**
-         * 加入 PK 直播房间
-         * @roomId PK 房间 ID
+         * 加入副直播房间
+         * @roomId 副房间的 roomId
          */
         joinOtherRoom(roomId) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -10796,11 +10923,19 @@
                 if (this._context.getConnectionStatus() !== engine.ConnectionStatus.CONNECTED) {
                     return { code: exports.RCRTCCode.SIGNAL_DISCONNECTED };
                 }
-                logger.debug(`joinPKRoom, roomId: ${roomId}`);
+                logger.debug(`JoinPKRoom, roomId: ${roomId}`);
+                if (this._joinedPKRooms[roomId]) {
+                    return { code: exports.RCRTCCode.REPERT_JOIN_ROOM };
+                }
                 const livingType = exports.RCLivingType.VIDEO; // signal 不处理 livingType 故写死 RCLivingType.VIDEO
-                const { code, data } = yield this._context.joinRTCRoom(roomId, engine.RTCMode.LIVE, livingType);
+                // 加入副房间时，携带主房间 Id，用于在房间内区分人员身份
+                const extraUserData = {
+                    key: 'extra',
+                    value: `{"roomId": "${this._mainRoomId}"}`
+                };
+                const { code, data } = yield this._context.joinRTCRoom(roomId, engine.RTCMode.LIVE, livingType, undefined, extraUserData);
                 if (code !== engine.ErrorCode.SUCCESS) {
-                    logger.error(`joinRoom failed -> code: ${code}`);
+                    logger.error(`JoinPKRoom failed -> code: ${code}`);
                     return { code: code };
                 }
                 logger.debug(`JoinPKRoom success -> userId: ${this._context.getCurrentId()}, roomId: ${roomId}, data: ${JSON.stringify(data)}`);
@@ -10808,45 +10943,47 @@
                 // 回调主直播房间，已加入 PK 房间
                 this._joinedPKRooms[roomId] = room;
                 this._onJoinedPKRoom(roomId, room);
-                const joinLivingResData = { room, code: exports.RCRTCCode.SUCCESS, userIds: room.getRemoteUserIds(), tracks: room.getRemoteTracks() };
-                // 手动模式时，用户加入房间，需返回 CDN 开关状态
-                if (room.__getCDNPushMode() === RCInnerCDNPushMode.MANUAL) {
-                    Object.assign(joinLivingResData, { CDNEnable: room.__getCDNEnable() });
-                }
-                return joinLivingResData;
+                return { room, code: exports.RCRTCCode.SUCCESS, userIds: room.getRemoteUserIds(), tracks: room.getRemoteTracks() };
             });
         }
         /**
-         * 退出 PK 直播房间房间
-         * @param room 要离开的 PK 房间 room 实例
+         * 退出副房间
+         * @param room 要退出的副房间的 room 实例
+         * @param isQuitPK 是否要结束连麦
          */
         leaveOtherRoom(room, isQuitPK) {
             return __awaiter(this, void 0, void 0, function* () {
                 return push(() => __awaiter(this, void 0, void 0, function* () {
                     const roomId = room.getRoomId();
+                    logger.debug(`leavePKRoom -> userId: ${this._context.getCurrentId()} , roomId: ${roomId}`);
+                    yield room.__destroy(true);
+                    // 回调主直播房间离开 PK 房间
+                    delete this._joinedPKRooms[roomId];
+                    this._onLeavePKRoom(roomId);
                     if (!this._PKInfo[roomId]) {
                         return { code: exports.RCRTCCode.SUCCESS };
                     }
                     // isQuitPK 为 true 时，结束连麦
                     isQuitPK && this._quitRoomPK(roomId);
-                    yield room.__destroy(true);
-                    logger.debug(`leavePKRoom -> userId: ${this._context.getCurrentId()} , roomId: ${roomId}`);
-                    // 回调主直播房间离开 PK 房间
-                    delete this._joinedPKRooms[roomId];
-                    this._onLeavePKRoom(roomId);
-                    delete this._PKInfo[roomId];
                     return { code: exports.RCRTCCode.SUCCESS };
                 }));
             });
         }
         /**
-         * 获取 _PKInfo
+         * 获取连麦信息
+         * @param roomId 连麦房间的 roomId
          */
         getPKInfo(roomId) {
             return this._PKInfo[roomId];
         }
         /**
-         * 获取已加入的 PK 房间
+         * 获取所有连麦信息
+         */
+        getAllPKInfo() {
+            return this._PKInfo;
+        }
+        /**
+         * 获取已加入的副房间
          */
         getJoinedPKRooms() {
             return this._joinedPKRooms;
@@ -10875,11 +11012,43 @@
             this._mcuConfigBuilder = new RCMCUConfigBuilder(this._onMCUConfigFlush.bind(this), this._isValidResourceId.bind(this), this._sendCDNInfoSignal.bind(this));
             // 初始化 RCLivingPKHandler
             if (this._isMainRoom) {
-                this._roomPKHandler = new RCLivingPKHandler(context, runtime, service, initOptions, this, super._registerPKMsgListener.bind(this), this._onJoinedPKRoom.bind(this), this._onLeavePKRoom.bind(this));
+                const PKInfo = getPKInfoByRoomData(this._roomId, data.roomInfo);
+                this._roomPKHandler = new RCLivingPKHandler(PKInfo, context, runtime, service, initOptions, this, super._registerPKMsgListener.bind(this), this._onJoinedPKRoom.bind(this), this._onLeavePKRoom.bind(this));
             }
             const CDNUris = (_a = data.roomInfo.filter((item) => { return item.key === 'cdn_uris'; })[0]) === null || _a === void 0 ? void 0 : _a.value;
             CDNUris && (this._CDNUris = JSON.parse(CDNUris)[0]);
         }
+        /**
+         * resourceId 有效性验证
+         * @param resourceId
+         */
+        _isValidResourceId(resourceId) {
+            var _a;
+            const { userId } = parseTrackId(resourceId);
+            // 是否是主房间资源
+            const isHostRoomResource = !!((_a = this._roomResources[userId]) === null || _a === void 0 ? void 0 : _a.find(item => getTrackId(item) === resourceId));
+            // 是否是主房间资源
+            let isPKRoomResource = false;
+            /**
+             * 无副房间时，只验证是否为主房间资源
+             */
+            const { code, roomPKHandler } = this.getRoomPKHandler();
+            if (code !== exports.RCRTCCode.SUCCESS || !roomPKHandler) {
+                return isHostRoomResource;
+            }
+            /**
+             * 有副房间时，需验证是否为主房间或副房间资源
+             */
+            const joinedPKRooms = roomPKHandler.getJoinedPKRooms();
+            const PKRoomRemoteTracks = [];
+            Object.values(joinedPKRooms).map((room) => {
+                PKRoomRemoteTracks.push(...room.getRemoteTracks());
+            });
+            isPKRoomResource = PKRoomRemoteTracks.some((track) => {
+                return resourceId === track.getTrackId();
+            });
+            return isHostRoomResource || isPKRoomResource;
+        }
         getLivingType() {
             return this._livingType;
         }
@@ -10887,6 +11056,10 @@
          * 获取 MCU 配置构建对象
          */
         getMCUConfigBuilder() {
+            if (!this._isMainRoom) {
+                logger.error('the `getMCUConfigBuilder` is disabled in PK room ');
+                return { code: exports.RCRTCCode.THE_FUNCTION_IS_DISABLED_IN_PKROOM };
+            }
             return this._mcuConfigBuilder;
         }
         /**
@@ -10943,6 +11116,10 @@
          */
         enableInnerCDN(enable) {
             return __awaiter(this, void 0, void 0, function* () {
+                if (!this._isMainRoom) {
+                    logger.error('the `enableInnerCDN` is disabled in PK room ');
+                    return { code: exports.RCRTCCode.THE_FUNCTION_IS_DISABLED_IN_PKROOM };
+                }
                 if (!engine.isBoolean(enable)) {
                     logger.error('`enable` is invalid');
                     return { code: exports.RCRTCCode.PARAMS_ERROR };
@@ -11066,7 +11243,7 @@
          * 观众切换为主播后直接处理人员变更及资源变更
          */
         _afterChangedRole(data) {
-            const parseData = parseRoomData(data);
+            const parseData = parseRoomData(data, this._roomId);
             const currentUserId = this._context.getCurrentId();
             const joinedAnchorList = Object.keys(parseData);
             // 观众升级主播成功后返回房间实例，才可注册房间事件，需异步抛出
@@ -11116,33 +11293,46 @@
          */
         _onJoinedPKRoom(roomId, room) {
             /**
-             * 连麦双方加入副房间之后，如果己方发布过资源，
+             * 加入副房间之后，如果己方发布过资源，且参与连麦，
              * 需携带 pushOtherRooms 与 mediaServer 重新交互
              */
-            const pubTracks = this.getLocalTracks();
-            if (!pubTracks.length) {
-                return;
+            const { code, roomPKHandler } = this.getRoomPKHandler();
+            if (code === exports.RCRTCCode.SUCCESS && roomPKHandler) {
+                const PKInfo = roomPKHandler.getPKInfo(roomId);
+                if (!PKInfo) {
+                    return;
+                }
+                this._exchangeWithPushOtherRoom();
             }
-            this._exchangeWithPushOtherRoom(roomId);
         }
+        /**
+         * 离开 PK 房间后，如果参与过连麦，pushOtherRooms 需去掉退出的连麦房间配置，重新和 mediaServer 交互
+         */
         _onLeavePKRoom(roomId) {
+            const { code, roomPKHandler } = this.getRoomPKHandler();
+            if (code === exports.RCRTCCode.SUCCESS && roomPKHandler) {
+                const PKInfo = roomPKHandler.getPKInfo(roomId);
+                if (!PKInfo) {
+                    return;
+                }
+                this._exchangeWithPushOtherRoom();
+            }
         }
         /**
          * 携带 pushOtherRooms 与 mediaServer 重新交互
-         * @param roomId 副房间 roomId
          */
-        _exchangeWithPushOtherRoom(roomId) {
+        _exchangeWithPushOtherRoom() {
             return __awaiter(this, void 0, void 0, function* () {
+                /**
+                 * 如果己方未发布过资源，无需发请求
+                 */
+                const pubTracks = this.getLocalTracks();
+                if (!pubTracks.length) {
+                    return;
+                }
                 const reqBody = yield this._createExchangeParams(this._subscribedList, false);
-                const joinedPKRooms = this._roomPKHandler.getJoinedPKRooms();
-                const sessionId = joinedPKRooms[roomId].getSessionId();
-                const { inviterUserAutoMix: autoMix } = this._roomPKHandler.getPKInfo(roomId);
-                const pushOtherRooms = {
-                    roomId,
-                    sessionId,
-                    autoMix: autoMix
-                };
-                reqBody.pushOtherRooms = [pushOtherRooms];
+                const pushOtherRooms = this._getPushOtherRoomsParams();
+                pushOtherRooms && (reqBody.pushOtherRooms = pushOtherRooms);
                 const resp = yield this._exchangeHandle(reqBody);
                 if (resp.code !== exports.RCRTCCode.SUCCESS) {
                     logger.error(`reTryExchange failed: ${resp.code}`);
@@ -11161,6 +11351,7 @@
         }
         /**
          * 获取 PK 业务处理器
+         * @since version 5.3.0
          */
         getRoomPKHandler() {
             if (!this._isMainRoom) {
@@ -11175,14 +11366,14 @@
             };
         }
         /**
-         * 退出 PK 房间
+         * 退出所有连麦房间
          */
-        _quitPKRoom() {
+        _quitAllPKRoom() {
             const PKRooms = this._roomPKHandler.getJoinedPKRooms();
-            const roomIds = Object.keys(PKRooms);
-            roomIds.forEach((roomId) => {
-                this._context.quitRTCRoom(roomId);
-            });
+            for (const roomId in PKRooms) {
+                const room = PKRooms[roomId];
+                this._roomPKHandler.leaveOtherRoom(room);
+            }
         }
     }
 
@@ -11199,7 +11390,7 @@
         'Content-Type': 'application/json;charset=UTF-8',
         'Cache-Control': 'no-cache',
         ClientType: `web|${browserInfo.browser}|${browserInfo.version}`,
-        ClientVersion: "5.3.0-rtc-roompk.1",
+        ClientVersion: "5.3.2-alpha.1",
         'Client-Session-Id': getUUID(),
         'Request-Id': Date.now().toString()
     });
@@ -12248,7 +12439,7 @@
                 /**
                  * CDN 资源减少: 上次 CDNUris 中有 url，变更后无 url
                  */
-                if (this._CDNUris.url && newCDNUris.url) {
+                if (this._CDNUris.url && !newCDNUris.url) {
                     this._callAppListener('onCDNInfoDisable');
                     /**
                      * 更新内存中存储的 cdn_uris 数据
@@ -12607,13 +12798,35 @@
             if (message.conversationType !== engine.ConversationType.RTC_ROOM) {
                 return false;
             }
-            const PKRooms = this._getJoinedPKRooms();
-            PKRooms.forEach((room) => {
-                room.__parseInnerMessage(message);
-            });
+            // 给连麦房间增加消息处理器
+            if (this._crtRoom instanceof RCLivingRoom) {
+                const PKRooms = this._getJoinedPKRoomList();
+                PKRooms.forEach((room) => {
+                    room.__parseInnerMessage(message);
+                });
+            }
             (_a = this._crtRoom) === null || _a === void 0 ? void 0 : _a.__parseInnerMessage(message);
             return true;
         }
+        /**
+         * 获取加入的连麦房间
+         */
+        _getJoinedPKRoomList() {
+            const { code, roomPKHandler } = this._crtRoom.getRoomPKHandler();
+            if (code === exports.RCRTCCode.SUCCESS && roomPKHandler) {
+                const PKRooms = roomPKHandler.getJoinedPKRooms() || {};
+                return Object.values(PKRooms);
+            }
+            return [];
+        }
+        _getPKRoomIds() {
+            const { code, roomPKHandler } = this._crtRoom.getRoomPKHandler();
+            if (code === exports.RCRTCCode.SUCCESS && roomPKHandler) {
+                const PKInfo = roomPKHandler.getAllPKInfo();
+                return Object.keys(PKInfo);
+            }
+            return [];
+        }
         /**
          * 获取当前用户 Id，若 IM 未连接，这返回 `''`
          * @returns
@@ -12697,7 +12910,7 @@
                 logger.debug(`JoinRoom success -> userId: ${this._context.getCurrentId()}, roomId: ${roomId}, data: ${JSON.stringify(data)}`);
                 const room = new RCLivingRoom(this._context, this._runtime, roomId, data, this._service, this._options, this._releaseCrtRoomObj.bind(this), livingType, false, true);
                 this._crtRoom = room;
-                const joinLivingResData = { room, code: exports.RCRTCCode.SUCCESS, userIds: room.getRemoteUserIds(), tracks: room.getRemoteTracks() };
+                const joinLivingResData = { room, code: exports.RCRTCCode.SUCCESS, userIds: room.getRemoteUserIds(), tracks: room.getRemoteTracks(), PKRoomIds: this._getPKRoomIds() };
                 // 手动模式时，用户加入房间，需返回 CDN 开关状态
                 if (room.__getCDNPushMode() === RCInnerCDNPushMode.MANUAL) {
                     Object.assign(joinLivingResData, { CDNEnable: room.__getCDNEnable() });
@@ -12714,25 +12927,18 @@
             }
             return this._audience;
         }
-        _getJoinedPKRooms() {
-            if (this._crtRoom instanceof RCLivingRoom) {
-                const { code, roomPKHandler } = this._crtRoom.getRoomPKHandler();
-                if (code === exports.RCRTCCode.SUCCESS && roomPKHandler) {
-                    const PKRooms = roomPKHandler.getJoinedPKRooms();
-                    return Object.values(PKRooms);
-                }
-            }
-            return [];
-        }
         _onIMStatusChange(status) {
             logger.debug(`signal server connection state change: ${status}`);
             if (status !== engine.ConnectionStatus.CONNECTED) {
                 return;
             }
-            const PKRooms = this._getJoinedPKRooms();
-            PKRooms.forEach((room) => {
-                room.__onReconnected();
-            });
+            // 给连麦房间增加重连处理
+            if (this._crtRoom instanceof RCLivingRoom) {
+                const PKRooms = this._getJoinedPKRoomList();
+                PKRooms.forEach((room) => {
+                    room.__onReconnected();
+                });
+            }
             this._crtRoom && this._crtRoom.__onReconnected();
         }
         _onIMDisconnect() {
@@ -12887,7 +13093,7 @@
          * @param tag 屏幕共享视轨数据标识
          * @param options
          * @description
-         * 支持 Electron 平台下通过制定 `chromeMediaSrouceId` 的方式获取屏幕共享视频。
+         * 支持 Electron 平台下通过制定 `chromeMediaSourceId` 的方式获取屏幕共享视频。
          * 参考：https://www.electronjs.org/docs/api/desktop-capturer
          */
         createScreenVideoTrack(tag = 'screenshare', options) {
@@ -13095,13 +13301,10 @@
                 return {
                     room,
                     code: exports.RCRTCCode.SUCCESS,
-                    remoteInfo: {
-                        remoteUserIds: room.getRemoteUserIds(),
-                        remoteRTCTracks: room.getRemoteRTCTracks(),
-                        remoteMCUTracks: room.getRemoteMCUTracks(),
-                        remoteTracks: room.getRemoteTracks(),
-                        CDNUris: room.getCDNInfo()
-                    }
+                    userIds: room.getRemoteUserIds(),
+                    RTCTracks: room.getRemoteRTCTracks(),
+                    MCUTracks: room.getRemoteMCUTracks(),
+                    CDNUris: room.getCDNInfo()
                 };
             });
         }
@@ -13145,7 +13348,7 @@
                 this._crtRoom = crtRoom;
                 // 重置观众房间
                 this._crtAudienceLivingRoom = null;
-                return { room: crtRoom, code: exports.RCRTCCode.SUCCESS };
+                return { room: crtRoom, code: exports.RCRTCCode.SUCCESS, userIds: room.getRemoteUserIds(), tracks: crtRoom.getRemoteTracks() };
             });
         }
         /**
@@ -13176,13 +13379,10 @@
                 return {
                     room: crtRoom,
                     code: exports.RCRTCCode.SUCCESS,
-                    remoteInfo: {
-                        remoteUserIds: crtRoom.getRemoteUserIds(),
-                        remoteRTCTracks: crtRoom.getRemoteRTCTracks(),
-                        remoteMCUTracks: crtRoom.getRemoteMCUTracks(),
-                        remoteTracks: crtRoom.getRemoteTracks(),
-                        CDNUris: crtRoom.getCDNInfo()
-                    }
+                    userIds: crtRoom.getRemoteUserIds(),
+                    RTCTracks: crtRoom.getRemoteRTCTracks(),
+                    MCUTracks: crtRoom.getRemoteMCUTracks(),
+                    CDNUris: crtRoom.getCDNInfo()
                 };
             });
         }
@@ -13229,9 +13429,9 @@
                 logger.error('Please use the https protocol or use `http://localhost` to open the page!');
                 return false;
             }
-            engine.VersionManage.add('plugin-rtc', "5.3.0-rtc-roompk.1");
-            if (!engine.VersionManage.validEngine("5.1.0-rtc-roompk.1")) {
-                logger.error(`The current engine version '${engine.VersionManage.getInfo().engine}' error, plugin-rtc required engine version at least '${"5.1.0-rtc-roompk.1"}'.`);
+            engine.VersionManage.add('plugin-rtc', "5.3.2-alpha.1");
+            if (!engine.VersionManage.validEngine("5.1.2-alpha.1")) {
+                logger.error(`The current engine version '${engine.VersionManage.getInfo().engine}' error, plugin-rtc required engine version at least '${"5.1.2-alpha.1"}'.`);
                 return false;
             }
             return true;
@@ -13239,7 +13439,7 @@
         setup(context, runtime, options = {}) {
             logger.setLogLevel(options.logLevel);
             logger.setLogStdout(options.logStdout);
-            logger.warn(`RCRTC Version: ${"5.3.0-rtc-roompk.1"}, Commit: ${"381b45b74bd1cee88cf1e6e79108809734bb17ea"}`);
+            logger.warn(`RCRTC Version: ${"5.3.2-alpha.1"}, Commit: ${"db999e233480c8537357ef17495b0bbb67c692fe"}`);
             logger.warn(`browserInfo.browser -> ${browserInfo.browser}`);
             logger.warn(`browserInfo.supportsUnifiedPlan -> ${browserInfo.supportsUnifiedPlan}`);
             logger.warn(`browserInfo.version -> ${browserInfo.version}`);