import JsSIP from "jssip";
|
import { Notification, MessageBox, Message, Loading } from "element-ui";
|
// 医院机构与SIP服务器映射配置
|
const HOSPITAL_CONFIG = {
|
丽水市中医院: {
|
wsUrl: "wss://192.168.10.124:7443",
|
domain: "192.168.10.124",
|
},
|
龙泉市人民医院: {
|
wsUrl: "wss://10.10.0.220:7443",
|
domain: "10.10.0.220",
|
},
|
// 可以继续添加其他医院配置
|
default: {
|
wsUrl: "wss://192.168.10.124:7443",
|
domain: "192.168.10.124",
|
},
|
};
|
class SipService {
|
constructor() {
|
this.ua = null;
|
this.currentSession = null;
|
this.onStatusChange = null;
|
this.onCallStatusChange = null;
|
this.onIncomingCall = null;
|
this.isRegistered = false; // 新增注册状态标志
|
this.registrationTime = null; // 新增注册成功时间戳
|
this.currentConfig = null; // 存储当前配置
|
}
|
// 获取医院配置方法
|
getHospitalConfig() {
|
const orgName = localStorage.getItem("orgname");
|
return HOSPITAL_CONFIG[orgName] || HOSPITAL_CONFIG.default;
|
}
|
init(baseConfig) {
|
try {
|
// 获取机构名称，如果没有传入则从localStorage读取
|
const orgName = baseConfig.orgName || localStorage.getItem("orgname");
|
|
// 根据机构名称获取对应的服务器配置
|
const hospitalConfig = this.getHospitalConfig(orgName);
|
console.log(hospitalConfig, "88");
|
|
// 合并配置
|
this.currentConfig = {
|
...baseConfig,
|
...hospitalConfig,
|
};
|
|
console.log(
|
`当前机构: ${orgName}, 使用服务器: ${this.currentConfig.domain}`
|
);
|
|
this.updateStatus("connecting", "连接中...");
|
console.log(baseConfig.sipUri, "baseConfig.sipUri");
|
|
this.ua = new JsSIP.UA({
|
sockets: [new JsSIP.WebSocketInterface(this.currentConfig.wsUrl)],
|
uri: baseConfig.sipUri, // 这里使用基础的sipUri，domain部分会被动态替换
|
password: baseConfig.password,
|
display_name: baseConfig.displayName,
|
iceServers: [],
|
register: true,
|
sessionExpires: 1800,
|
minSessionExpires: 90,
|
register_expires: 300,
|
});
|
|
this.ua.start();
|
|
// 事件监听
|
this.ua.on("registered", () => {
|
this.isRegistered = true;
|
this.registrationTime = Date.now(); // 记录注册成功时间
|
console.log(this.registrationTime, "注册时间");
|
|
this.updateStatus("registered", "已注册");
|
});
|
|
this.ua.on("registrationFailed", (e) => {
|
this.isRegistered = false;
|
this.updateStatus("failed", `注册失败: ${e.cause}`);
|
});
|
|
this.ua.on("unregistered", () => {
|
this.isRegistered = false;
|
let registrationTime = Date.now(); // 记录注销成功时间
|
console.log(registrationTime, "注销时间");
|
this.updateStatus("disconnected", "已注销");
|
});
|
this.ua.on("disconnected", () =>
|
this.updateStatus("disconnected", "连接断开")
|
);
|
this.ua.on("connected", () =>
|
this.updateStatus("connecting", "重新连接中...")
|
);
|
this.ua.on("newRTCSession", (data) =>
|
this.handleIncomingCall(data.session)
|
);
|
} catch (error) {
|
this.updateStatus("failed", `初始化失败: ${error.message}`);
|
console.error("SIP初始化失败:", error);
|
throw error;
|
}
|
}
|
// 新增方法：检查是否可以呼叫
|
canMakeCall(minDelay = 2000) {
|
if (!this.isRegistered) {
|
return { canCall: false, reason: "SIP未注册，无法呼叫" };
|
}
|
|
const now = Date.now();
|
const timeSinceRegistration = now - this.registrationTime;
|
|
if (timeSinceRegistration < minDelay) {
|
const remaining = minDelay - timeSinceRegistration;
|
return {
|
canCall: false,
|
reason: `注册成功，资源加载中请等待 ${Math.ceil(
|
remaining / 1000
|
)} 秒后再呼叫`,
|
};
|
}
|
|
return { canCall: true, reason: "" };
|
}
|
makeCall(targetNumber) {
|
const { canCall, reason } = this.canMakeCall();
|
if (!canCall) {
|
Message.error(reason);
|
return Promise.reject(new Error(reason));
|
}
|
return new Promise((resolve, reject) => {
|
try {
|
if (!this.ua) {
|
throw new Error("SIP客户端未初始化");
|
}
|
|
if (!this.ua.isRegistered()) {
|
throw new Error("SIP未注册，无法呼叫");
|
}
|
const targetUri = `sip:${targetNumber}@${this.currentConfig.domain}`;
|
console.log(`呼叫目标: ${targetUri}`);
|
const options = {
|
sessionTimers: true, // 启用会话计时器
|
sessionTimersExpires: 150,
|
extraHeaders: ["Accept: application/sdp"],
|
mediaConstraints: { audio: true, video: false },
|
rtcOfferConstraints: {
|
offerToReceiveAudio: true,
|
offerToReceiveVideo: false,
|
},
|
eventHandlers: {
|
progress: () => this.updateCallStatus("calling", "呼叫中..."),
|
failed: (e) => {
|
this.handleCallFailure(e, reject);
|
},
|
ended: () => this.updateCallStatus("ended", "通话结束"),
|
confirmed: () => {
|
this.updateCallStatus("connected", "通话已接通");
|
resolve();
|
},
|
},
|
};
|
|
this.currentSession = this.ua.call(targetUri, options);
|
|
this.setupPeerConnection(this.currentSession);
|
this.setupAudio(this.currentSession);
|
} catch (error) {
|
this.updateCallStatus("failed", `呼叫失败22: ${error.message}`);
|
reject(error);
|
}
|
});
|
}
|
|
setupPeerConnection(session) {
|
session.on("peerconnection", (pc) => {
|
const originalCreateOffer = pc.createOffer.bind(pc);
|
|
pc.createOffer = async (offerOptions) => {
|
try {
|
const offer = await originalCreateOffer(offerOptions);
|
return this.normalizeSDP(offer);
|
} catch (error) {
|
console.error("创建Offer失败:", error);
|
throw error;
|
}
|
};
|
});
|
}
|
|
// normalizeSDP(offer) {
|
// let sdp = offer.sdp;
|
// console.log("原始SDP:", sdp); // 调试用，捕获原始SDP
|
// // 标准化SDP
|
// sdp = sdp.replace(/c=IN IP4.*\r\n/, "c=IN IP4 0.0.0.0\r\n");
|
// sdp = sdp.replace(
|
// /m=audio \d+.*\r\n/,
|
// "m=audio 9 UDP/TLS/RTP/SAVPF 0 8\r\n"
|
// );
|
|
// // 确保包含基本编解码器
|
// if (!sdp.includes("PCMU/8000")) sdp += "a=rtpmap:0 PCMU/8000\r\n";
|
// if (!sdp.includes("PCMA/8000")) sdp += "a=rtpmap:8 PCMA/8000\r\n";
|
|
// // 添加必要属性
|
// sdp += "a=rtcp-mux\r\n";
|
// sdp += "a=sendrecv\r\n";
|
|
// console.log("标准化后的SDP:", sdp);
|
// return new RTCSessionDescription({
|
// type: offer.type,
|
// sdp: sdp,
|
// });
|
// }
|
// 在 SipService 类中新增方法，用于获取针对特定服务器的SDP处理策略
|
getSDPNormalizationStrategy(orgName) {
|
const strategies = {
|
龙泉市人民医院: "conservative", // 保守策略：最小化修改，优先兼容
|
丽水市中医院: "aggressive", // 激进策略：保持原有强标准化逻辑
|
// 可以为其他机构添加更多策略
|
};
|
return strategies[orgName] || "moderate"; // 默认策略
|
}
|
|
/**
|
* 标准化SDP Offer - 修复龙泉市人民医院488错误
|
* 核心思路：从“强制覆盖”改为“智能修补”，针对不同服务器使用差异化策略
|
*/
|
normalizeSDP(offer) {
|
const orgName = localStorage.getItem("orgname");
|
const strategy = this.getSDPNormalizationStrategy(orgName);
|
let sdp = offer.sdp;
|
|
console.log(`[SDP标准化] 机构: ${orgName}, 策略: ${strategy}`);
|
console.log("[SDP标准化] 原始SDP:", sdp);
|
|
if (strategy === "conservative") {
|
// ==================== 保守策略：针对龙泉市人民医院等严格服务器 ====================
|
// 原则：除非必要，否则不修改原有SDP结构，仅添加缺失的关键属性
|
|
// 1. 谨慎处理连接地址：仅在地址是明显内网地址时才修改
|
const privateIPRegex =
|
/c=IN IP4 (192\.168|10\.|172\.(1[6-9]|2[0-9]|3[0-1]))/;
|
if (privateIPRegex.test(sdp)) {
|
sdp = sdp.replace(/c=IN IP4.*\r\n/, "c=IN IP4 0.0.0.0\r\n");
|
console.log("[SDP标准化] 已修改连接地址为 0.0.0.0");
|
}
|
|
// 2. 保持媒体行原样，不强制修改端口和协议
|
// sdp = sdp.replace(/m=audio \d+.*\r\n/, "m=audio 9 UDP/TLS/RTP/SAVPF 0 8\r\n");
|
|
// 3. 智能添加基础编解码器映射（仅在缺失时添加）
|
const codecMappings = [
|
{ pt: 0, name: "PCMU/8000" },
|
{ pt: 8, name: "PCMA/8000" },
|
];
|
|
codecMappings.forEach((codec) => {
|
const rtpmapPattern = `a=rtpmap:${codec.pt} ${codec.name}`;
|
const payloadPattern = ` ${codec.pt} `;
|
|
// 只有当SDP中包含该负载类型但缺少详细映射时才添加
|
if (sdp.includes(payloadPattern) && !sdp.includes(rtpmapPattern)) {
|
sdp += `${rtpmapPattern}\r\n`;
|
console.log(`[SDP标准化] 已添加编解码器映射: ${rtpmapPattern}`);
|
}
|
});
|
|
// 4. 条件性添加必要属性（避免重复）
|
const essentialAttributes = [
|
{ attr: "a=rtcp-mux", desc: "RTCP复用" },
|
{ attr: "a=sendrecv", desc: "双向媒体流" },
|
];
|
|
essentialAttributes.forEach((item) => {
|
if (!sdp.includes(item.attr)) {
|
sdp += `${item.attr}\r\n`;
|
console.log(`[SDP标准化] 已添加属性: ${item.desc}`);
|
}
|
});
|
} else if (strategy === "aggressive") {
|
// ==================== 激进策略：保持原有逻辑 ====================
|
sdp = sdp.replace(/c=IN IP4.*\r\n/, "c=IN IP4 0.0.0.0\r\n");
|
sdp = sdp.replace(
|
/m=audio \d+.*\r\n/,
|
"m=audio 9 UDP/TLS/RTP/SAVPF 0 8\r\n"
|
);
|
|
// 确保包含基础编解码器
|
if (!sdp.includes("PCMU/8000")) sdp += "a=rtpmap:0 PCMU/8000\r\n";
|
if (!sdp.includes("PCMA/8000")) sdp += "a=rtpmap:8 PCMA/8000\r\n";
|
|
// 添加通用属性
|
sdp += "a=rtcp-mux\r\n";
|
sdp += "a=sendrecv\r\n";
|
} else {
|
// ==================== 默认策略：平衡方案 ====================
|
// 适度修改，兼顾兼容性和功能性
|
sdp = sdp.replace(/c=IN IP4.*\r\n/, "c=IN IP4 0.0.0.0\r\n");
|
|
// 仅在媒体行格式明显异常时修改
|
if (!sdp.match(/m=audio \d+ RTP\/AVP/)) {
|
sdp = sdp.replace(
|
/m=audio \d+.*\r\n/,
|
"m=audio 9 UDP/TLS/RTP/SAVPF 0 8\r\n"
|
);
|
}
|
|
// 智能添加缺失的属性
|
if (!sdp.includes("a=rtcp-mux")) sdp += "a=rtcp-mux\r\n";
|
if (!sdp.includes("a=sendrecv")) sdp += "a=sendrecv\r\n";
|
}
|
|
console.log("[SDP标准化] 标准化后SDP:", sdp);
|
return new RTCSessionDescription({
|
type: offer.type,
|
sdp: sdp,
|
});
|
}
|
|
/**
|
* 增强的SDP调试方法 - 用于对比分析
|
*/
|
debugSDPComparison(originalOffer, normalizedOffer, context) {
|
console.group(`[SDP调试] ${context}`);
|
console.log(
|
"原始SDP媒体行:",
|
originalOffer.sdp.match(/m=audio.*\r\n/)?.[0] || "未找到"
|
);
|
console.log(
|
"标准化后媒体行:",
|
normalizedOffer.sdp.match(/m=audio.*\r\n/)?.[0] || "未找到"
|
);
|
console.log(
|
"原始编解码器列表:",
|
originalOffer.sdp.match(/a=rtpmap:\d+.*\r\n/g) || []
|
);
|
console.log(
|
"标准化后编解码器列表:",
|
normalizedOffer.sdp.match(/a=rtpmap:\d+.*\r\n/g) || []
|
);
|
console.groupEnd();
|
}
|
|
// 在 setupPeerConnection 方法中集成调试功能
|
setupPeerConnection(session) {
|
session.on("peerconnection", (pc) => {
|
const originalCreateOffer = pc.createOffer.bind(pc);
|
|
pc.createOffer = async (offerOptions) => {
|
try {
|
const offer = await originalCreateOffer(offerOptions);
|
const normalizedOffer = this.normalizeSDP(offer);
|
|
// 调试信息输出
|
this.debugSDPComparison(offer, normalizedOffer, "Offer创建阶段");
|
|
return normalizedOffer;
|
} catch (error) {
|
console.error("创建Offer失败:", error);
|
throw error;
|
}
|
};
|
});
|
}
|
handleCallFailure(e, reject) {
|
if (e.response?.status_code === 422) {
|
const serverMinSE = e.response.headers["Min-SE"]?.[0]?.raw || "未知";
|
console.error(`服务器要求 Min-SE ≤ ${serverMinSE}，当前设置: 120`);
|
}
|
console.error("呼叫失败详情:", {
|
cause: e.cause,
|
message: e.message,
|
response: e.response && {
|
status: e.response.status_code,
|
reason: e.response.reason_phrase,
|
},
|
});
|
|
let errorMessage = "呼叫失败";
|
switch (e.cause) {
|
case "Incompatible SDP":
|
errorMessage = "媒体协商失败，请检查编解码器配置";
|
break;
|
case "488":
|
case "606":
|
errorMessage = "对方设备不支持当前媒体配置";
|
break;
|
case "422":
|
errorMessage = "会话参数不满足服务器要求";
|
break;
|
default:
|
errorMessage = `呼叫失败3: ${e.cause || e.message}`;
|
}
|
|
this.updateCallStatus("failed55", errorMessage);
|
reject(new Error(errorMessage));
|
}
|
|
setupAudio(session) {
|
session.connection.addEventListener("addstream", (e) => {
|
const audioElement = document.getElementById("remoteAudio");
|
if (audioElement) {
|
audioElement.srcObject = e.stream;
|
}
|
});
|
}
|
|
endCall() {
|
if (this.currentSession) {
|
this.currentSession.terminate();
|
this.updateCallStatus("ended", "通话已结束");
|
this.currentSession = null;
|
}
|
}
|
|
updateStatus(type, text) {
|
console.log(`SIP状态更新: ${type} - ${text}`);
|
if (this.onStatusChange) {
|
this.onStatusChange({ type, text });
|
}
|
}
|
|
updateCallStatus(type, text) {
|
console.log(`通话状态更新: ${type} - ${text}`);
|
if (this.onCallStatusChange) {
|
this.onCallStatusChange({ type, text });
|
}
|
}
|
|
handleIncomingCall(session) {
|
if (session.direction === "incoming") {
|
console.log("来电:", session.remote_identity.uri.toString());
|
if (this.onIncomingCall) {
|
this.onIncomingCall(session);
|
}
|
}
|
}
|
}
|
|
export default new SipService();
|
