WebRTC 实现无插件多端视频通话

2、配置实体类 (呼叫排队、信令消息、消息类型枚举)

/**
 * 呼叫排队
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CallWaitItem {
    private String fromUserId; // 呼叫方 ID
    private String toUserId; // 被叫方 ID
    private String offerData; // 缓存的 Offer 数据
    private long queueTime; // 排队时间戳（毫秒）
    private int queueIndex; // 队列位置
}

/**
 * WebRTC 信令消息
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true) // 忽略未知字段
public class WebrtcMessage {
    private String type; // 消息类型（对应 WebrtcMessageType）
    private String fromUserId; // 发送方 ID
    private String toUserId; // 接收方 ID
    private String data; // 核心数据（SDP/ICE/提示信息等）
}

/**
 * WebRTC 消息类型枚举
 */
@Getter
public enum WebrtcMessageType {
    OFFER("offer"), // 发起呼叫
    ANSWER("answer"), // 接听呼叫
    ICE_CANDIDATE("iceCandidate"), // 网络候选信息
    LEAVE("leave"), // 主动挂断/取消呼叫
    REJECT("reject"), // 拒接呼叫
    ERROR("error"), // 错误消息
    PING("ping"), // 心跳检测
    QUEUE_UPDATE("queueUpdate"), // 排队状态更新
    QUEUE_TIMEOUT("queueTimeout"), // 排队超时
    OFFLINE_NOTIFY("offlineNotify"); // 对方离线通知

    private final String type;

    WebrtcMessageType(String type) {
        this.type = type;
    }

    /**
     * 通过字符串获取枚举
     * @param type
     * @return
     */
    public static WebrtcMessageType getByType(String type) {
        for (WebrtcMessageType messageType : values()) {
            if (messageType.getType().equals(type)) {
                return messageType;
            }
        }
        return null;
    }
}

3、添加 WebRTC 信令消息处理器（转发消息 + 通话逻辑处理）

/**
 * WebRTC 信令消息处理器
 */
@Slf4j
@Component
public class WebrtcSignalingHandler extends TextWebSocketHandler {
    // ========== 全局核心映射 ==========
    private static final Map<String, WebSocketSession> ONLINE_SESSIONS = new ConcurrentHashMap<>(); // 在线用户会话映射
    private static final Map<String, String> CALL_BIND_MAP = new ConcurrentHashMap<>(); // 通话绑定映射
    private static final Map<String, List<CallWaitItem>> CALL_WAIT_QUEUE_MAP = new ConcurrentHashMap<>(); // 通话排队队列映射

    // ========== 可配置常量 ==========
    private static final long QUEUE_TIMEOUT_MS = 5 * 60 * 1000; // 排队超时时间（毫秒）
    private static final boolean ENABLE_QUEUE = true; // 排队功能开关
    private static final long PING_TIMEOUT_MS = 3000; // WebSocket 的超时时间

    // ========== 全局工具对象 ==========
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); // JSON 映射对象

    // ========== WebSocket 连接生命周期处理 ==========
    /**
     * 连接建立后触发
     * @param session
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // 获取并验证用户 ID
        String userId = getUserIdFromSession(session);
        if (userId == null || userId.trim().isEmpty()) {
            session.close(CloseStatus.BAD_DATA.withReason("缺少有效的用户 ID（URL 拼接?userId=[ID]）"));
            log.warn("【WebSocket 连接失败】缺少有效用户 ID，会话 URL：{}，会话 ID：{}", session.getUri(), session.getId());
            return;
        }
        // 重复登录：强制下线旧会话
        if (ONLINE_SESSIONS.containsKey(userId)) {
            WebSocketSession oldSession = ONLINE_SESSIONS.get(userId);
            if (oldSession != null && oldSession.isOpen()) {
                oldSession.close(CloseStatus.POLICY_VIOLATION.withReason("该账号在其他设备登录，已被强制下线"));
                log.info("【WebSocket 重复登录】用户【{}】在新设备登录，已强制下线旧设备（旧会话 ID：{}）", userId, oldSession.getId());
            }
            ONLINE_SESSIONS.remove(userId);
        }
        ONLINE_SESSIONS.put(userId, session);
        session.getAttributes().put("userId", userId);
        log.info("【WebSocket 连接成功】用户【{}】，会话 ID：{}，当前在线人数：{}", userId, session.getId(), ONLINE_SESSIONS.size());
    }

    /**
     * 连接关闭后触发
     * @param session
     * @param status
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        // 从会话属性中获取用户 ID
        String userId = (String) session.getAttributes().get("userId");
        if (userId == null) {
            log.warn("【WebSocket 连接关闭】会话无有效用户 ID，会话 ID：{}，关闭状态：{}", session.getId(), status);
            return;
        }
        // 清理用户相关所有数据，并通知通话对象
        cleanUserRelatedData(userId, true);
        log.info("【WebSocket 连接关闭】用户【{}】，会话 ID：{}，当前在线人数：{}，关闭状态：{}", userId, session.getId(), ONLINE_SESSIONS.size(), status);
    }

    /**
     * 连接出现异常后触发
     * @param session
     * @param exception
     * @throws Exception
     */
    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        String userId = (String) session.getAttributes().get("userId");
        if (userId != null) {
            // 清理用户相关所有数据，不通知通话对象
            cleanUserRelatedData(userId, false);
            log.error("【WebSocket 会话异常】用户【{}】，会话 ID：{}，当前在线人数：{}", userId, session.getId(), ONLINE_SESSIONS.size(), exception);
        } else {
            log.warn("【WebSocket 会话异常】无有效用户 ID，会话 ID：{}", session.getId(), exception);
        }
        if (session.isOpen()) {
            session.close(CloseStatus.SERVER_ERROR.withReason("会话内部异常，已自动关闭"));
        }
    }

    // ========== 核心消息分发处理 ==========
    /**
     * 收到消息后触发
     * @param session
     * @param message
     * @throws Exception
     */
    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        String fromUserId = (String) session.getAttributes().get("userId");
        if (fromUserId == null) {
            log.warn("【消息处理失败】发送方会话无有效用户 ID，会话 ID：{}", session.getId());
            return;
        }
        String rawMessage = message.getPayload();
        log.info("【收到信令消息】用户【{}】，会话 ID：{}，原始消息内容：{}", fromUserId, session.getId(), rawMessage);
        try {
            // 解析消息并补全数据
            WebrtcMessage webrtcMessage = OBJECT_MAPPER.readValue(rawMessage, WebrtcMessage.class);
            webrtcMessage.setFromUserId(fromUserId);

            // 获取并验证接收方 ID
            String toUserId = webrtcMessage.getToUserId();
            if (toUserId == null || toUserId.trim().isEmpty()) {
                sendErrorMsg(session, "缺少接收方用户 ID（toUserId）");
                return;
            }
            if (fromUserId.equals(toUserId)) {
                sendErrorMsg(session, "无法呼叫自身，请输入其他用户 ID");
                return;
            }

            // 统一使用枚举分发消息，避免硬编码错误
            WebrtcMessageType msgType = WebrtcMessageType.getByType(webrtcMessage.getType());
            if (msgType == null) {
                sendErrorMsg(session, "不支持的消息类型：" + webrtcMessage.getType());
                return;
            }

            // 分发消息
            switch (msgType) {
                case OFFER:
                    handleOfferMessage(session, webrtcMessage, fromUserId, toUserId);
                    break;
                case ANSWER:
                    handleAnswerMessage(webrtcMessage, fromUserId, toUserId);
                    break;
                case REJECT:
                    handleRejectMessage(webrtcMessage, fromUserId, toUserId);
                    break;
                case LEAVE:
                    handleLeaveMessage(webrtcMessage, fromUserId, toUserId);
                    break;
                case ICE_CANDIDATE:
                    handleIceCandidateMessage(webrtcMessage, fromUserId, toUserId);
                    break;
                case PING:
                    // 心跳消息：仅更新会话状态，不做额外处理
                    break;
                default:
                    sendErrorMsg(session, "暂未实现的消息类型：" + msgType.getType());
            }
        } catch (Exception e) {
            sendErrorMsg(session, "消息处理失败：格式错误或服务器内部异常");
            log.error("【消息处理异常】用户【{}】，会话 ID：{}，原始消息：{}", fromUserId, session.getId(), rawMessage, e);
        }
    }

    // ========== 业务消息处理 ==========
    /**
     * 处理呼叫请求（Offer）：统一处理空闲/占线/排队
     * @param session
     * @param message
     * @param fromUserId
     * @param toUserId
     * @throws Exception
     */
    private void handleOfferMessage(WebSocketSession session, WebrtcMessage message, String fromUserId, String toUserId) throws Exception {
        log.info("【处理发起呼叫】呼叫方【{}】→ 被叫方【{}】，开始处理 OFFER 消息", fromUserId, toUserId);
        // 判断被叫方是否在线
        if (!isUserOnline(toUserId)) {
            log.warn("【发起呼叫失败】被叫方【{}】未在线或连接已关闭，呼叫方【{}】", toUserId, fromUserId);
            sendErrorMsg(session, "对方【" + toUserId + "】未在线或连接已关闭");
            return;
        }
        // 判断被叫方是否忙线（通话中/正在处理来电）
        if (isUserBusy(toUserId)) {
            if (!ENABLE_QUEUE) {
                log.warn("【发起呼叫失败】被叫方【{}】正忙，未开启排队功能，呼叫方【{}】", toUserId, fromUserId);
                sendErrorMsg(session, "对方【" + toUserId + "】正忙，无法接听（未开启排队功能）");
                return;
            }
            log.info("【被叫方忙线】呼叫方【{}】→ 被叫方【{}】，准备加入排队队列", fromUserId, toUserId);
            // 被叫方忙线且开启排队，处理排队逻辑（去重 + 新增排队项）
            List<CallWaitItem> waitQueue = CALL_WAIT_QUEUE_MAP.getOrDefault(toUserId, new CopyOnWriteArrayList<>());
            // 去重处理，避免重复加入排队队列
            boolean isDuplicate = waitQueue.stream().anyMatch(item -> item.getFromUserId().equals(fromUserId));
            if (isDuplicate) {
                CallWaitItem existItem = waitQueue.stream()
                        .filter(item -> item.getFromUserId().equals(fromUserId))
                        .findFirst()
                        .orElse(null);
                if (existItem != null) {
                    // 已在队列中：更新排队状态提示
                    sendQueueUpdateMsg(getUserSession(fromUserId), toUserId, existItem.getQueueIndex(), waitQueue.size());
                    log.debug("【排队去重】呼叫方【{}】已在被叫方【{}】的排队队列中（第{}位），无需重复加入", fromUserId, toUserId, existItem.getQueueIndex());
                }
                return;
            }
            // 新增排队项：缓存 Offer 数据和排队信息
            CallWaitItem waitItem = new CallWaitItem();
            waitItem.setFromUserId(fromUserId);
            waitItem.setToUserId(toUserId);
            waitItem.setOfferData(message.getData());
            waitItem.setQueueTime(System.currentTimeMillis());
            waitItem.setQueueIndex(waitQueue.size() + 1);
            // 排队项加入队列，更新队列映射
            waitQueue.add(waitItem);
            CALL_WAIT_QUEUE_MAP.put(toUserId, waitQueue);
            // 通知呼叫方当前排队状态
            sendQueueUpdateMsg(session, toUserId, waitItem.getQueueIndex(), waitQueue.size());
            log.info("用户【{}】呼叫【{}】：被叫方忙线，已加入排队（第{}位，总{}人）", fromUserId, toUserId, waitItem.getQueueIndex(), waitQueue.size());
            return;
        }
        // 被叫方空闲，转发 Offer，绑定临时通话状态
        CALL_BIND_MAP.put(toUserId, fromUserId); // 标记被叫方为忙线（处理来电中）
        forwardMessage(message, toUserId);
        log.info("【转发 Offer 成功】呼叫方【{}】→ 被叫方【{}】，对方空闲，已完成临时通话绑定", fromUserId, toUserId);
    }

    /**
     * 处理接听呼叫（Answer）：建立双向通话绑定，完成 SDP 协商
     * @param message
     * @param answererId
     * @param callerId
     * @throws Exception
     */
    private void handleAnswerMessage(WebrtcMessage message, String answererId, String callerId) throws Exception {
        log.info("【处理接听呼叫】接听方【{}】→ 呼叫方【{}】，开始处理 ANSWER 消息", answererId, callerId);
        // 验证双方是否在线
        if (!isUserOnline(callerId) || !isUserOnline(answererId)) {
            log.warn("【接听呼叫失败】双方或一方已离线，接听方【{}】，呼叫方【{}】", answererId, callerId);
            sendErrorMsg(getUserSession(answererId), "对方已离线，无法完成接听");
            return;
        }
        // 建立双向通话绑定
        CALL_BIND_MAP.put(callerId, answererId);
        CALL_BIND_MAP.put(answererId, callerId);
        // 转发 Answer 给呼叫方，完成通话建立
        forwardMessage(message, callerId);
        log.info("【建立双向通话成功】接听方【{}】↔ 呼叫方【{}】，已完成双向通话绑定，开始传输媒体流", answererId, callerId);
    }

    /**
     * 处理拒接呼叫（Reject）：通知呼叫方，触发下一个排队呼叫
     * @param message
     * @param rejecterId
     * @param callerId
     * @throws Exception
     */
    private void handleRejectMessage(WebrtcMessage message, String rejecterId, String callerId) throws Exception {
        log.info("【处理拒接呼叫】拒接方【{}】→ 呼叫方【{}】，开始处理 REJECT 消息", rejecterId, callerId);
        // 通知呼叫方被拒接
        WebSocketSession callerSession = getUserSession(callerId);
        if (callerSession != null && callerSession.isOpen()) {
            message.setData("对方【" + rejecterId + "】已拒接你的呼叫");
            forwardMessage(message, callerId);
            log.debug("【拒接通知发送成功】拒接方【{}】→ 呼叫方【{}】", rejecterId, callerId);
        }
        // 清理当前通话绑定，触发下一个排队呼叫
        cleanCallBind(rejecterId, callerId);
        processNextWaitItem(rejecterId);
        log.info("【拒接呼叫处理完成】拒接方【{}】，呼叫方【{}】，已清理通话绑定并触发下一个排队项", rejecterId, callerId);
    }

    /**
     * 处理主动挂断（Leave）：通知对方，清理通话状态，触发下一个排队呼叫
     * @param message
     * @param operatorId
     * @param targetId
     * @throws Exception
     */
    private void handleLeaveMessage(WebrtcMessage message, String operatorId, String targetId) throws Exception {
        log.info("【处理主动挂断】操作方【{}】→ 目标方【{}】，开始处理 LEAVE 消息", operatorId, targetId);
        if ("cancelCall".equals(message.getData())) {
            // 通知目标方对方已取消
            if (isUserOnline(targetId)) {
                message.setData("对方【" + operatorId + "】已取消呼叫");
                forwardMessage(message, targetId);
                log.debug("【取消呼叫发送成功】操作方【{}】→ 目标方【{}】", operatorId, targetId);
            }
            // 从排队列表移除挂断方的数据
            for (List<CallWaitItem> waitQueue : CALL_WAIT_QUEUE_MAP.values()) {
                waitQueue.removeIf(item -> item.getFromUserId().equals(operatorId));
            }
            // 触发下一个排队呼叫转发
            List<CallWaitItem> updatedWaitQueue = CALL_WAIT_QUEUE_MAP.getOrDefault(targetId, new CopyOnWriteArrayList<>());
            // 如果挂断方是当前绑定的通话就移除绑定，然后触发下一个排队项
            if (operatorId.equals(CALL_BIND_MAP.get(targetId))) {
                cleanCallBind(operatorId, targetId);
            }
            if (CALL_BIND_MAP.get(targetId) == null) {
                // 取出队列头部，转发 Offer 给被叫方
                if (updatedWaitQueue.size() > 0) {
                    CallWaitItem nextItem = updatedWaitQueue.remove(0);
                    try {
                        // 构建 Offer 消息，复用缓存的 Offer 数据
                        WebrtcMessage offerMsg = new WebrtcMessage();
                        offerMsg.setType(WebrtcMessageType.OFFER.getType());
                        offerMsg.setFromUserId(nextItem.getFromUserId());
                        offerMsg.setToUserId(targetId);
                        offerMsg.setData(nextItem.getOfferData());
                        // 标记被叫方为忙线避免重复来电，再转发 Offer
                        CALL_BIND_MAP.put(targetId, nextItem.getFromUserId());
                        forwardMessage(offerMsg, targetId);
                        // 更新剩余排队项的索引，通知所有排队用户状态
                        updateWaitQueueIndex(updatedWaitQueue, targetId);
                        log.info("【队列调度成功】呼叫方【{}】的 Offer 消息已转发给被叫方【{}】，剩余排队人数：{}", nextItem.getFromUserId(), targetId, updatedWaitQueue.size());
                    } catch (Exception e) {
                        log.error("【队列调度失败】转发 Offer 消息给被叫方【{}】异常，排队项：{}", targetId, nextItem, e);
                        // 异常时：递归处理下一个排队项，避免队列阻塞
                        processNextWaitItem(targetId);
                    }
                }
            } else {
                // 取消的不是当前绑定通话，只需要更新排队索引
                updateWaitQueueIndex(updatedWaitQueue, targetId);
            }
            log.info("【主动取消处理完成】操作方【{}】，目标方【{}】，已清理通话绑定并触发排队项调度", operatorId, targetId);
        } else {
            // 通知目标方对方已挂断
            if (isUserOnline(targetId)) {
                message.setData("对方【" + operatorId + "】已挂断通话");
                forwardMessage(message, targetId);
                log.debug("【挂断通知发送成功】操作方【{}】→ 目标方【{}】", operatorId, targetId);
            }
            // 清理通话绑定，触发下一个排队呼叫
            cleanCallBind(operatorId, targetId);
            processNextWaitItem(operatorId);
            processNextWaitItem(targetId);
            log.info("【主动挂断处理完成】操作方【{}】，目标方【{}】，已清理通话绑定并触发排队项调度", operatorId, targetId);
        }
    }

    /**
     * 处理 ICE 候选消息：仅转发
     * @param message
     * @param fromUserId
     * @param toUserId
     * @throws Exception
     */
    private void handleIceCandidateMessage(WebrtcMessage message, String fromUserId, String toUserId) throws Exception {
        log.debug("【处理 ICE 候选消息】发送方【{}】→ 接收方【{}】，准备转发", fromUserId, toUserId);
        // 验证接收方是否在线
        if (isUserOnline(toUserId)) {
            // 转发
            forwardMessage(message, toUserId);
            log.info("【ICE 候选消息转发成功】发送方【{}】→ 接收方【{}】", fromUserId, toUserId);
        } else {
            log.warn("【ICE 候选消息转发失败】接收方【{}】已离线，发送方【{}】", toUserId, fromUserId);
            sendErrorMsg(getUserSession(fromUserId), "对方已离线，无法转发 ICE 候选消息");
        }
    }

    // ========== 排队队列逻辑 ==========
    /**
     * 处理下一个排队项：被叫方空闲后，自动转发下一个呼叫方的 Offer 消息
     * @param toUserId
     */
    private void processNextWaitItem(String toUserId) {
        if (!ENABLE_QUEUE) {
            CALL_WAIT_QUEUE_MAP.remove(toUserId);
            log.debug("【排队功能关闭】已清理被叫方【{}】的排队队列", toUserId);
            return;
        }
        // 获取被叫方的排队队列
        List<CallWaitItem> waitQueue = CALL_WAIT_QUEUE_MAP.getOrDefault(toUserId, new CopyOnWriteArrayList<>());
        if (waitQueue.isEmpty()) {
            CALL_WAIT_QUEUE_MAP.remove(toUserId);
            log.debug("【排队队列为空】被叫方【{}】无待处理的排队项，已清理队列映射", toUserId);
            return;
        }
        // 取出队列头部，转发 Offer 给被叫方
        CallWaitItem nextItem = waitQueue.remove(0);
        try {
            // 构建 Offer 消息，复用缓存的 Offer 数据
            WebrtcMessage offerMsg = new WebrtcMessage();
            offerMsg.setType(WebrtcMessageType.OFFER.getType());
            offerMsg.setFromUserId(nextItem.getFromUserId());
            offerMsg.setToUserId(toUserId);
            offerMsg.setData(nextItem.getOfferData());
            // 标记被叫方为忙线避免重复来电，再转发 Offer
            CALL_BIND_MAP.put(toUserId, nextItem.getFromUserId());
            forwardMessage(offerMsg, toUserId);
            // 更新剩余排队项的索引，通知所有排队用户状态
            updateWaitQueueIndex(waitQueue, toUserId);
            log.info("【队列调度成功】呼叫方【{}】的 Offer 消息已转发给被叫方【{}】，剩余排队人数：{}", nextItem.getFromUserId(), toUserId, waitQueue.size());
        } catch (Exception e) {
            log.error("【队列调度失败】转发 Offer 消息给被叫方【{}】异常，排队项：{}", toUserId, nextItem, e);
            // 异常时：递归处理下一个排队项，避免队列阻塞
            processNextWaitItem(toUserId);
        }
        // 清理空队列
        if (waitQueue.isEmpty()) {
            CALL_WAIT_QUEUE_MAP.remove(toUserId);
        } else {
            CALL_WAIT_QUEUE_MAP.put(toUserId, waitQueue);
        }
    }

    /**
     * 更新排队项索引，通知所有排队用户当前状态
     * @param waitQueue
     * @param toUserId
     */
    private void updateWaitQueueIndex(List<CallWaitItem> waitQueue, String toUserId) {
        log.debug("【更新排队索引】被叫方【{}】，待更新排队项数量：{}", toUserId, waitQueue.size());
        for (int i = 0; i < waitQueue.size(); i++) {
            CallWaitItem item = waitQueue.get(i);
            item.setQueueIndex(i + 1);
            try {
                sendQueueUpdateMsg(getUserSession(item.getFromUserId()), toUserId, item.getQueueIndex(), waitQueue.size());
                log.debug("【排队状态更新】已通知用户【{}】，当前排队位置：第{}位，总人数：{}", item.getFromUserId(), item.getQueueIndex(), waitQueue.size());
            } catch (Exception e) {
                log.error("【排队状态更新失败】无法推送消息给排队用户【{}】", item.getFromUserId(), e);
            }
        }
    }

    // ========== 辅助工具方法 ==========
    /**
     * 判断用户是否在线
     * @param userId
     * @return
     */
    private boolean isUserOnline(String userId) {
        WebSocketSession session = ONLINE_SESSIONS.get(userId);
        boolean isOnline = session != null && session.isOpen();
        log.debug("【用户在线判断】用户【{}】，在线状态：{}", userId, isOnline);
        return isOnline;
    }

    /**
     * 判断用户是否忙线（通话中/正在处理来电）
     * @param userId
     * @return
     */
    private boolean isUserBusy(String userId) {
        boolean isBusy = CALL_BIND_MAP.containsKey(userId);
        log.debug("【用户忙线判断】用户【{}】，忙线状态：{}", userId, isBusy);
        return isBusy;
    }

    /**
     * 转发消息给目标用户
     * @param message
     * @param targetId
     * @throws Exception
     */
    private void forwardMessage(WebrtcMessage message, String targetId) throws Exception {
        WebSocketSession targetSession = ONLINE_SESSIONS.get(targetId);
        if (targetSession != null && targetSession.isOpen()) {
            String msgJson = OBJECT_MAPPER.writeValueAsString(message);
            targetSession.sendMessage(new TextMessage(msgJson));
            log.debug("【消息转发成功】消息类型：{}，转发至用户【{}】，消息内容：{}", message.getType(), targetId, msgJson);
            return;
        }
        log.warn("【消息转发失败】目标用户【{}】未在线或会话已关闭", targetId);
    }

    /**
     * 从会话 URL 中获取用户 ID
     * @param session
     * @return
     */
    private String getUserIdFromSession(WebSocketSession session) {
        try {
            // 获取 URL 中的查询参数
            String query = session.getUri().getQuery();
            if (query == null || query.isEmpty()) {
                log.warn("【获取用户 ID 失败】会话 URL 无查询参数，会话 ID：{}", session.getId());
                return null;
            }
            for (String param : query.split("&")) {
                String[] keyValue = param.split("=", 2);
                if (keyValue.length == 2 && "userId".equals(keyValue[0])) {
                    String userId = keyValue[1];
                    log.debug("【提取用户 ID 成功】会话 ID：{}，提取到用户 ID：{}", session.getId(), userId);
                    return userId;
                }
            }
            log.warn("【提取用户 ID 失败】查询参数中无 userId 字段，会话 ID：{}，查询参数：{}", session.getId(), query);
            return null;
        } catch (Exception e) {
            log.error("【提取用户 ID 异常】会话 ID：{}", session.getId(), e);
            return null;
        }
    }

    /**
     * 获取用户对应的 WebSocket 会话对象
     * @param userId
     * @return
     */
    private WebSocketSession getUserSession(String userId) {
        WebSocketSession session = ONLINE_SESSIONS.getOrDefault(userId, null);
        log.debug("【获取用户会话】用户【{}】，会话是否存在：{}", userId, session != null);
        return session;
    }

    /**
     * 发送错误提示消息
     */
    private void sendErrorMsg(WebSocketSession session, String errorMsg) throws Exception {
        if (session == null || !session.isOpen()) {
            log.warn("【发送错误消息失败】会话已关闭或不存在，错误消息：{}", errorMsg);
            return;
        }
        // 构建消息并发送
        WebrtcMessage errorMessage = new WebrtcMessage();
        errorMessage.setType(WebrtcMessageType.ERROR.getType());
        errorMessage.setData(errorMsg);
        String msgJson = OBJECT_MAPPER.writeValueAsString(errorMessage);
        session.sendMessage(new TextMessage(msgJson));
        log.debug("【错误消息发送成功】会话 ID：{}，错误消息：{}", session.getId(), errorMsg);
    }

    /**
     * 发送排队状态更新消息
     * @param session
     * @param toUserId
     * @param queueIndex
     * @param totalCount
     * @throws Exception
     */
    private void sendQueueUpdateMsg(WebSocketSession session, String toUserId, int queueIndex, int totalCount) throws Exception {
        if (session == null || !session.isOpen()) {
            log.warn("【发送排队状态消息失败】会话已关闭或不存在，被叫方【{}】，排队位置：{}", toUserId, queueIndex);
            return;
        }
        // 构建消息并发送
        WebrtcMessage queueMsg = new WebrtcMessage();
        queueMsg.setType(WebrtcMessageType.QUEUE_UPDATE.getType());
        queueMsg.setToUserId(toUserId);
        String queueData = String.format("{\"queueIndex\":%d,\"totalCount\":%d}", queueIndex, totalCount);
        queueMsg.setData(queueData);
        String msgJson = OBJECT_MAPPER.writeValueAsString(queueMsg);
        session.sendMessage(new TextMessage(msgJson));
        log.debug("【排队状态消息发送成功】会话 ID：{}，被叫方【{}】，排队位置：第{}位，总人数：{}", session.getId(), toUserId, queueIndex, totalCount);
    }

    /**
     * 发送排队超时消息
     * @param session
     * @throws Exception
     */
    private void sendQueueTimeoutMsg(WebSocketSession session) throws Exception {
        if (session == null || !session.isOpen()) {
            log.warn("【发送排队超时消息失败】会话已关闭或不存在");
            return;
        }
        // 构建消息并发送
        WebrtcMessage timeoutMsg = new WebrtcMessage();
        timeoutMsg.setType(WebrtcMessageType.QUEUE_TIMEOUT.getType());
        timeoutMsg.setData("排队超时，已退出队列");
        String msgJson = OBJECT_MAPPER.writeValueAsString(timeoutMsg);
        session.sendMessage(new TextMessage(msgJson));
        log.debug("【排队超时消息发送成功】会话 ID：{}", session.getId());
    }

    /**
     * 发送对方离线通知
     * @param targetId
     * @param offlineUserId
     * @throws Exception
     */
    private void sendOfflineNotifyMsg(String targetId, String offlineUserId) throws Exception {
        // 构建消息并转发给目标用户
        WebrtcMessage offlineMsg = new WebrtcMessage();
        offlineMsg.setType(WebrtcMessageType.OFFLINE_NOTIFY.getType());
        offlineMsg.setData("对方【" + offlineUserId + "】已掉线，通话已结束");
        forwardMessage(offlineMsg, targetId);
        log.debug("【对方离线通知发送成功】接收方【{}】，离线用户【{}】", targetId, offlineUserId);
    }

    /**
     * 清理通话绑定关系
     * @param userId1
     * @param userId2
     */
    private void cleanCallBind(String userId1, String userId2) {
        CALL_BIND_MAP.remove(userId1);
        CALL_BIND_MAP.remove(userId2);
        log.debug("【清理通话绑定】已清理用户【{}】和【{}】的通话绑定关系", userId1, userId2);
    }

    /**
     * 清理用户相关所有数据（会话/通话/排队）
     * @param userId
     * @param notifyPartner
     * @throws Exception
     */
    private void cleanUserRelatedData(String userId, boolean notifyPartner) throws Exception {
        log.info("【清理用户相关数据】开始清理用户【{}】的所有相关数据，是否通知通话对象：{}", userId, notifyPartner);
        // 移除在线会话映射，标记用户为离线
        ONLINE_SESSIONS.remove(userId);
        // 通知通话对象对方离线
        String callPartnerId = CALL_BIND_MAP.get(userId);
        if (callPartnerId != null && notifyPartner) {
            sendOfflineNotifyMsg(callPartnerId, userId);
            cleanCallBind(userId, callPartnerId);
            // 触发通话对象的下一个排队项调度
            processNextWaitItem(callPartnerId);
        }
        // 清理该用户作为被叫方的排队队列
        CALL_WAIT_QUEUE_MAP.remove(userId);
        // 清理该用户作为呼叫方的所有排队项（跨所有被叫方队列）
        for (List<CallWaitItem> waitQueue : CALL_WAIT_QUEUE_MAP.values()) {
            waitQueue.removeIf(item -> item.getFromUserId().equals(userId));
        }
        log.info("【清理用户相关数据完成】用户【{}】的所有数据已清理完毕", userId);
    }

    // ========== 定时任务 ==========
    /**
     * 清理过期排队项
     */
    @Scheduled(fixedRate = 10 * 1000)
    private void cleanExpiredWaitItems() {
        if (!ENABLE_QUEUE) {
            return;
        }
        long currentTime = System.currentTimeMillis();
        for (Map.Entry<String, List<CallWaitItem>> entry : CALL_WAIT_QUEUE_MAP.entrySet()) {
            String toUserId = entry.getKey();
            List<CallWaitItem> waitQueue = entry.getValue();
            // 筛选过期排队项
            List<CallWaitItem> expiredItems = waitQueue.stream()
                    .filter(item -> (currentTime - item.getQueueTime()) > QUEUE_TIMEOUT_MS)
                    .collect(Collectors.toList());
            // 清理过期项，通知用户
            for (CallWaitItem expiredItem : expiredItems) {
                waitQueue.remove(expiredItem);
                try {
                    sendQueueTimeoutMsg(getUserSession(expiredItem.getFromUserId()));
                    log.debug("【定时任务 - 清理过期排队项】清理，当前时间戳：{}，待处理队列数量：{}", currentTime, CALL_WAIT_QUEUE_MAP.size());
                } catch (Exception e) {
                    log.error("【定时任务 - 清理过期排队项】推送超时提示给用户【{}】失败", expiredItem.getFromUserId(), e);
                }
                log.info("【定时任务 - 清理过期排队项】已清理用户【{}】呼叫【{}】的过期排队项（排队超时）", expiredItem.getFromUserId(), toUserId);
            }
            // 更新剩余排队项索引
            updateWaitQueueIndex(waitQueue, toUserId);
            // 移除空队列
            if (waitQueue.isEmpty()) {
                CALL_WAIT_QUEUE_MAP.remove(toUserId);
            }
        }
    }

    /**
     * 清理无效 WebSocket 会话（每 10 秒执行一次）
     */
    @Scheduled(fixedRate = 10 * 1000)
    private void cleanInvalidSessions() {
        for (String userId : ONLINE_SESSIONS.keySet()) {
            WebSocketSession session = ONLINE_SESSIONS.get(userId);
            if (session == null || !session.isOpen()) {
                try {
                    cleanUserRelatedData(userId, false);
                } catch (Exception e) {
                    log.error("【定时任务 - 清理无效会话】清理用户【{}】数据失败", userId, e);
                }
                log.info("【定时任务 - 清理无效会话】已清理用户【{}】的无效 WebSocket 会话", userId);
            } else {
                boolean isSessionValid = sendPingWithTimeout(session);
                if (!isSessionValid) {
                    log.info(String.format("【定时任务 - 清理无效会话】用户【%s】的 WebSocket 会话 ping 超时，判定为无效并清理", userId));
                    ONLINE_SESSIONS.remove(userId);
                    if (session.isOpen()) {
                        try {
                            session.close(CloseStatus.GOING_AWAY.withReason("会话超时，已自动关闭"));
                        } catch (Exception ex) {
                            log.error("【定时任务 - 清理无效会话】关闭 WebSocket 无效会话失败：用户 ID【{}】", userId, ex);
                        }
                    }
                }
            }
        }
    }

    private boolean sendPingWithTimeout(WebSocketSession session) {
        FutureTask<Boolean> pingTask = new FutureTask<>(() -> {
            try {
                session.sendMessage(new TextMessage("{\"type\":\"ping\"}"));
                return true; // 发送成功，会话有效
            } catch (Exception e) {
                return false; // 发送异常，会话无效
            }
        });
        Thread pingThread = new Thread(pingTask, "WebSocket-Ping-Thread");
        pingThread.start();
        try {
            return pingTask.get(PING_TIMEOUT_MS, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            pingTask.cancel(true);
            return false;
        } catch (InterruptedException | ExecutionException e) {
            // 其他异常（线程中断、任务执行异常）：判定会话无效
            log.warn(String.format("【定时任务 - 清理无效会话】ping 操作出现异常：%s", e.getMessage()));
            return false;
        }
    }
}

4、添加 WebSocket 配置类

/**
 * WebSocket 配置类
 */
@Configuration
@EnableWebSocket
@EnableScheduling
public class WebSocketConfig implements WebSocketConfigurer {
    @Resource
    private WebrtcSignalingHandler webrtcSignalingHandler;

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) {
        webSocketHandlerRegistry
                .addHandler(webrtcSignalingHandler, "/webrtc") // 绑定处理器和访问端点
                .setAllowedOrigins("*"); // 允许跨域
    }

    /**
     * 定时任务线程池
     * @return
     */
    @Bean(name = "customWebSocketTaskScheduler")
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5); // 5 个线程处理定时任务
        scheduler.setThreadNamePrefix("websocket-scheduler-"); // 线程名前缀
        scheduler.setAwaitTerminationSeconds(10); // 任务关闭时等待秒数
        scheduler.setWaitForTasksToCompleteOnShutdown(true); // 关闭时等待任务完成
        return scheduler;
    }
}

5、启动类增加注解@EnableScheduling

@SpringBootApplication
@EnableScheduling
public class WebrtcServerApplication {
    private static Logger log = LoggerFactory.getLogger(WebrtcServerApplication.class);

    public static void main(String[] args) {
        SpringApplication.run(WebrtcServerApplication.class, args);
        log.info("========================================================================");
        log.info("=========================WebRTC 信令服务器启动成功==========================");
        log.info("--------WebSocket 访问端点：ws://[IP]:[Port]/webrtc?userId=[用户 ID]");
        log.info("========================================================================");
    }
}

6、测试连接

使用 Apipost 或其他工具创建 WebSocket 连接，连接地址（根据实际配置填写）：ws://[IP]:[Port]/webrtc?userId=[用户 ID]

二、HTML 页面

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>WebRTC 视频对讲</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; font-family: "Microsoft YaHei", sans-serif; }
        .container { width: 90%; max-width: 1200px; margin: 20px auto; }
        .input-area, .queue-area, .call-area { margin-bottom: 20px; padding: 15px; border: 1px solid #eee; border-radius: 8px; }
        .queue-area, .call-area { display: none; }
        .video-area { display: flex; gap: 20px; flex-wrap: wrap; }
        .video-box { flex: 1; min-width: 320px; }
        video { width: 100%; height: 360px; border: 1px solid #ccc; border-radius: 8px; background-color: #000; }
        button { padding: 8px 16px; margin: 5px; border: none; border-radius: 4px; cursor: pointer; font-size: 14px; }
        .btn-call { background-color: #4CAF50; color: white; }
        .btn-hangup, .btn-reject { background-color: #f44336; color: white; }
        .btn-answer { background-color: #2196F3; color: white; }
        input { padding: 8px; margin: 5px; border: 1px solid #ccc; border-radius: 4px; width: 200px; }
        .tip, .queue-tip { color: #666; font-size: 12px; margin-top: 10px; }
        .queue-highlight { color: #ff9800; font-weight: bold; }
    </style>
</head>
<body>
<div>
    <!-- 基础输入区域 -->
    <div>
        <h3>基础配置</h3>
        <label>自身用户 ID：</label>
        <input type="text" placeholder="输入自己的 ID" required>
        <button onclick="initWebSocket()">初始化连接</button>
        <br>
        <label>要呼叫的用户 ID：</label>
        <input type="text" placeholder="输入对方的 ID">
        <button onclick="callUser()">呼叫</button>
        <button onclick="hangupCall()">挂断/取消呼叫</button>
        <p>提示：先输入自身 ID 并初始化连接，再输入对方 ID 进行呼叫</p>
    </div>
    <!-- 排队状态区域 -->
    <div>
        <h3>排队状态</h3>
        <p>你正在呼叫 <span></span></p>
        <p>当前排队位置：第 <span>0</span> 位</p>
        <p>队列总人数：<span>0</span> 人</p>
        <p>提示：排队超时 5 分钟将自动退出，被叫方空闲后将自动为你转发请求</p>
    </div>
    <!-- 来电提示区域 -->
    <div>
        <h3>来电提醒</h3>
        <p>来自 <span></span> 的呼叫</p>
        <button onclick="answerCall()">接听</button>
        <button onclick="rejectCall()">拒接</button>
    </div>
    <!-- 视频播放区域 -->
    <div>
        <div>
            <h4>本地视频（静音）</h4>
            <video autoplay muted playsinline></video>
        </div>
        <div>
            <h4>远程视频</h4>
            <video autoplay playsinline></video>
        </div>
    </div>
</div>
<script src="js/jquery-3.5.1.min.js"></script>
<script>
/************************** 全局变量定义 **************************/
var webSocket = null; // WebSocket 实例
var peerConnection = null; // RTCPeerConnection 实例
var localStream = null; // 本地媒体流
var remoteStream = null; // 远程媒体流
var currentCallerId = null; // 当前来电方 ID
var isCallValid = false; // 通话是否有效
var isCalling = false; // 是否正在呼叫中
var pendingIceCandidates = []; // 待处理 ICE 候选队列
var webrtcServerUrl = "ws://192.168.1.190:9999/webrtc"; // 信令服务器 WebSocket 地址
var RTC_CONFIG = {iceServers: []}; // RTC 配置，内网环境不需要配置，需要内网穿透可以配置{iceServers: [{urls: "stun:stun.l.google.com:19302"},{urls: "stun1.l.google.com:19302"}]}

/************************** 浏览器兼容性处理 **************************/
// 兼容 RTCPeerConnection
window.RTCPeerConnection = window.RTCPeerConnection || window.webkitRTCPeerConnection || window.mozRTCPeerConnection;
// 兼容 RTCSessionDescription
window.RTCSessionDescription = window.RTCSessionDescription || window.webkitRTCSessionDescription || .;

. = . || . || .;

navigator. = navigator. || {};

 (!navigator..) {
    navigator.. = () {
        
         getUserMedia = navigator. || navigator.;
         (!getUserMedia) {
            
             .( ());
        }
        
          (() {
            getUserMedia.(navigator, constraints, resolve, reject);
        });
    };
}


 () {
    
     fromUserId = $().().();
     (!fromUserId) {
        ();
        .();
        ;
    }
    
     (webSocket && webSocket. === .) {
        .();
        webSocket.();
    }
    
     wsUrl = webrtcServerUrl +  + fromUserId;
    .(, wsUrl);
     {
        
        webSocket =  (wsUrl);
        
        webSocket. = () {
            .();
            ();
            
            $().();
        };
        
        webSocket. = () {
            .(, event);
            
            $().();
            $().();
            $().();
            .(, event., , event.);
            ();
        };
        
        webSocket. = () {
            .(, error);
            ();
        };
        
        webSocket. = () {
            .(, event.);
             {
                 msg = .(event.);
                .(, msg);
                
                (msg);
            }  (e) {
                .(, event., , e);
                ();
            }
        };
    }  (e) {
        .(, e);
        ();
    }
}


 () {
     msgType = msg.;
     fromUserId = msg.;
     data = msg.;
    
     ( == data) {
        ;
    }
    .(, msgType, , fromUserId, , data);
    
     (msgType) {
         :
            
            (fromUserId, data);
            ;
         :
            
            (data);
            ;
         :
            
            (data);
            ;
         :
            
            (fromUserId);
            ;
         :
            
            (fromUserId, data);
            ;
         :
            
            (data);
            ;
         :
            
            (data);
            ;
         :
            
            (data);
            ;
         :
            
            (data);
            ;
        :
            
            .(, msgType);
    }
}



 () {
    .(, fromUserId, , data);
    
     (peerConnection) {
        ();
        .();
        ;
    }
    
    currentCallerId = fromUserId;
    
    $().(fromUserId);
    $().();
    .();
    
    (() {
        
        ();
        
         offer =  ({ : , : data });
        
        peerConnection.(offer).(() {
            .();
            
             (pendingIceCandidates. > ) {
                .(, pendingIceCandidates.);
                pendingIceCandidates.(() {
                    (cacheData);
                });
                
                pendingIceCandidates = [];
            }
        }).(() {
            .(, error);
            ();
            
            ();
        });
    });
}


 () {
    .(, data);
    
     (!peerConnection) {
        .();
        ;
    }
    
     answer =  ({ : , : data });
    
    peerConnection.(answer).(() {
        .();
        
        isCalling = ;
        $().();
    }).(() {
        .(, error);
        ();
        isCalling = ;
        
        ();
    });
}


 () {
    .(, data);
    
     (!peerConnection) {
        .(, pendingIceCandidates. + );
        pendingIceCandidates.(data);
        ;
    }
     {
        
         iceCandidateData = .(data);
         iceCandidateCopy = .(.(iceCandidateData));
         (iceCandidateCopy.) {
            iceCandidateCopy. = iceCandidateCopy.;
             iceCandidateCopy.;
        }
         iceCandidateCopy.;
         iceCandidateCopy.;
        
         (!iceCandidateCopy.) {
            .();
            ;
        }
        
         iceCandidate =  (iceCandidateCopy);
        peerConnection.(iceCandidate).(() {
            .(, error);
        });
        .();
    }  (e) {
        .(, e);
    }
}


 () {
     rejectMsg =  + fromUserId + ;
    .( + rejectMsg);
    (rejectMsg);
    
    ();
}


 () {
     (data.()!=- || fromUserId==currentCallerId) {
         leaveMsg =  + fromUserId + ;
        .( + leaveMsg);
        (leaveMsg);
        
        ();
    }  {
         leaveMsg =  + fromUserId + ;
        .( + leaveMsg);
        (leaveMsg);
    }
}


 () {
    .(, data);
    
     (isCallValid) {
        isCallValid = ;
        ();
        (data);
    }
}


 () {
    .(, data);
     {
        
         queueInfo = .(data);
        
        $().(queueInfo.);
        $().(queueInfo.);
        $().($().().());
        $().();
        .( + queueInfo. +  + queueInfo. + );
    }  (e) {
        .(, e);
    }
}


 () {
    .( + data);
    (data);
    
    $().();
    ();
}


 () {
    .( + data);
    (data);
    
    ();
}


 () {
    
     mediaConstraints = {
        : { : { : , :  }, : { : , :  }, : { : , :  }, :  },
        : { : { : , :  }, : { : , :  }, : { : , :  }, : { : , :  } }
    };
    .(, mediaConstraints);
    
    navigator..(mediaConstraints).(() {
        
        localStream = stream;
        $()[]. = stream;
        .(, stream.().);
        
         ( callback === ) {
            ();
        }
    }).(() {
        .(, error);
        
         (error. === ) {
            .();
            (callback);
        }   (error. === ) {
            ();
        }   (error. === ) {
            ();
        }  {
            ( + error.);
        }
    });
}


 () {
    
     mediaConstraints = { : , : { : , :  } };
    .(, mediaConstraints);
    
    navigator..(mediaConstraints).(() {
        
        localStream = stream;
        $()[]. = stream;
        .(, stream.().);
        
         ( callback === ) {
            ();
        }
    }).(() {
        .(, error);
        ( + error.);
    });
}


 () {
    
     (peerConnection) {
        .();
        peerConnection.();
    }
    
    peerConnection =  ();
    .();
    
     (localStream) {
        localStream.().(() {
            peerConnection.(track, localStream);
            .(, track., , track.);
        });
    }
    
    peerConnection. = () {
         (event.) {
            .(, event.);
            
             iceCandidateCopy = .(.(event.));
            iceCandidateCopy. = iceCandidateCopy.;
             iceCandidateCopy.;
            
            ({ : , : .(iceCandidateCopy) });
        }  {
            .();
        }
    };
    
    peerConnection. = () {
        .(, event.., , event..);
        
         (!remoteStream) {
            remoteStream =  ();
            .();
        }
         track = event.;
        
         (!remoteStream.().( t. === track.)) {
            remoteStream.(track);
            .();
        }
        
        $()[]. = remoteStream;
        $()[].().(() {
            .(, error);
        });
    };
    
    peerConnection. = () {
         (!peerConnection) {
            ;
        }
         connState = peerConnection.;
        .(, connState);
        
         (connState ===  || connState === ) {
            .();
            ();
        }
    };
}


 () {
    
     (!webSocket || webSocket. !== .) {
        ();
        .(, webSocket ? webSocket. : );
        ;
    }
    
     toUserId = $().().();
     (msg. !==  && !toUserId && !currentCallerId) {
        ();
        .();
        ;
    }
    
     fullMsg = { : msg., : $().().(), : toUserId || currentCallerId, : msg. };
     {
         jsonMsg = .(fullMsg);
        webSocket.(jsonMsg);
        .(, msg., , fullMsg., , jsonMsg);
    }  (e) {
        .(, e);
        ();
    }
}


 () {
    
     toUserId = $().().();
     (!toUserId) {
        ();
        .();
        ;
    }
    .(, toUserId);
    
    (() {
        
        ();
        
        isCallValid = ;
        isCalling = ;
        
         offerOptions = { : , :  };
        .(, offerOptions);
        
        peerConnection.(offerOptions).(() {
             peerConnection.(offer);
        }).(() {
            
            ({ : , : peerConnection.. });
            
            $().();
            $().();
            .();
        }).(() {
            .(, error);
            ();
            isCalling = ;
            
            ();
        });
    });
}


 () {
    
     (!peerConnection || !currentCallerId) {
        ();
        .();
        ;
    }
    .(, currentCallerId, );
    
    isCallValid = ;
    
    peerConnection.().(() {
         peerConnection.(answer);
    }).(() {
        
        ({ : , : peerConnection.. });
        
        $().();
        $().();
        $().(currentCallerId);
        $().();
        .();
    }).(() {
        .(, error);
        ();
    });
}


 () {
    
     (currentCallerId && webSocket && webSocket. === .) {
        .(, currentCallerId, );
        ({ : , :  });
    }
    
    ();
    ();
    .();
}


 () {
     (isCalling) {
        
        .(, $().().());
         (webSocket && webSocket. === .) {
            ({ : , :  });
        }
        ();
        ();
    }  {
        
        .(, $().().());
         (webSocket && webSocket. === .) {
            ({ : , :  });
        }
        ();
        ();
    }
    .();
}


 () {
    .();
    
    isCallValid = ;
    isCalling = ;
    
     (localStream) {
        localStream.().(() {
            track.();
            .(, track.);
        });
        localStream = ;
        $()[]. = ;
        .();
    }
    
     (peerConnection) {
        
        peerConnection. = ;
        peerConnection. = ;
        peerConnection. = ;
        
        peerConnection.();
        peerConnection = ;
        .();
    }
    
     (remoteStream) {
        remoteStream.().(() {
            track.();
            .(, track.);
        });
        remoteStream = ;
        $()[]. = ;
        .();
    }
    
    $().();
    $().();
    $().();
    $().();
    $().();
    $().();
    .();
    
    currentCallerId = ;
    pendingIceCandidates = [];
    .();
}
</script>
</body>
</html>

三、配置浏览器

浏览器获取本地摄像头/麦克风需要有限制，地址需要满足任意一项：localhost、127.0.0.1、https，内网环境下想通过 IP 来访问需要配置 unsafely-treat-insecure-origin-as-secure

谷歌、Edge、360 浏览器

1. 进入浏览器配置页面

谷歌 / 360：chrome://flags/#unsafely-treat-insecure-origin-as-secure
Edge：edge://flags/#unsafely-treat-insecure-origin-as-secure

2. 启用【Insecure origins treated as secure】项，在输入框中添加需要对讲的系统地址【http://服务器 IP:项目端口】，多个地址之间使用英文【,】分隔

火狐浏览器

1. 搜索框中输入【insecure】 找到【media.devices.insecure.enabled】和【media.getusermedia.insecure.enabled】，点击后面的切换按钮，把值改为 true 后刷新页面

地址栏输入【about:config】

四、测试视频通话

创建了 4 个浏览器分别登录不同的 id，用来模拟一对一呼叫和多对一呼叫的情况

一对一呼叫

2 >>> 1

多对一呼叫（排队功能）

2 >>> 1，3 >>> 1，4 >>> 1

排队列表

用户 3 取消呼叫，用户 4 的排队顺位提升

用户 2 取消呼叫，用户 4 的呼叫请求传递到用户 1 并接听成功