SHA256
3007 lines
108 KiB
JavaScript
3007 lines
108 KiB
JavaScript
import { t } from '../i18n/index.js';
|
|
import { addAppLogEntry, addSignedMessageToChat, authService, authorizeSession, state } from '../state.js';
|
|
import { buildDmCallTechBlock } from './dm-tech-blocks.js';
|
|
|
|
const TYPES = {
|
|
INVITE: 100,
|
|
RINGING: 110,
|
|
ACCEPT: 120,
|
|
DECLINE_BUSY: 130,
|
|
TIMEOUT: 140,
|
|
HANGUP: 150,
|
|
CONNECT_START: 170,
|
|
OFFER: 200,
|
|
ANSWER: 210,
|
|
ICE: 220,
|
|
};
|
|
const SIGNAL_TARGET_SINGLE = 'single_session';
|
|
const SIGNAL_TARGET_ALL = 'all_sessions';
|
|
const CALL_SIGNAL_TYPES = Object.freeze({
|
|
[TYPES.INVITE]: 'call_invite',
|
|
[TYPES.RINGING]: 'call_ringing',
|
|
[TYPES.ACCEPT]: 'call_accept',
|
|
[TYPES.DECLINE_BUSY]: 'call_decline_busy',
|
|
[TYPES.TIMEOUT]: 'call_timeout',
|
|
[TYPES.HANGUP]: 'call_hangup',
|
|
[TYPES.CONNECT_START]: 'call_connect_start',
|
|
[TYPES.OFFER]: 'call_offer',
|
|
[TYPES.ANSWER]: 'call_answer',
|
|
[TYPES.ICE]: 'call_ice',
|
|
});
|
|
|
|
const calls = new Map();
|
|
const callStateListeners = new Set();
|
|
|
|
let activeCallId = '';
|
|
let debugReporter = null;
|
|
|
|
let audioContext = null;
|
|
let toneTimerId = null;
|
|
let toneName = '';
|
|
let toneFlip = false;
|
|
|
|
const DEFAULT_ICE_SERVERS = Object.freeze([
|
|
{ urls: 'stun:stun.l.google.com:19302' },
|
|
]);
|
|
const CALL_SUMMARY_MIN_TOTAL_MS = 5000;
|
|
const OUTGOING_NO_ACK_TIMEOUT_MS = 10_000;
|
|
const OUTGOING_DELIVERED_NO_ACK_TIMEOUT_MS = 25_000;
|
|
const INCOMING_CONNECT_TIMEOUT_MS = 20_000;
|
|
const MAX_TIMELINE_ENTRIES = 64;
|
|
const CAMERA_CONSTRAINTS = Object.freeze({
|
|
width: { ideal: 1280 },
|
|
height: { ideal: 720 },
|
|
frameRate: { ideal: 24, max: 30 },
|
|
facingMode: 'user',
|
|
});
|
|
const CALL_MODE_AUDIO = 'audio';
|
|
const CALL_MODE_VIDEO = 'video';
|
|
const CALL_MODE_INSTANT_VIDEO = 'instant_video';
|
|
const VIDEO_TRANSPORT_NONE = 'none';
|
|
const VIDEO_TRANSPORT_RESERVED = 'reserved';
|
|
const VIDEO_TRANSPORT_SLOT = 'slot';
|
|
|
|
function nowMs() {
|
|
return Date.now();
|
|
}
|
|
|
|
function isMobileBrowser() {
|
|
const uaDataMobile = navigator?.userAgentData?.mobile;
|
|
if (typeof uaDataMobile === 'boolean') return uaDataMobile;
|
|
const ua = String(navigator?.userAgent || '');
|
|
return /Android|iPhone|iPad|iPod|Mobile/i.test(ua);
|
|
}
|
|
|
|
function canRouteAudioOutputInBrowser() {
|
|
const mediaProto = globalThis?.HTMLMediaElement?.prototype;
|
|
return Boolean(
|
|
window.isSecureContext
|
|
&& isMobileBrowser()
|
|
&& mediaProto
|
|
&& typeof mediaProto.setSinkId === 'function'
|
|
&& navigator?.mediaDevices
|
|
&& typeof navigator.mediaDevices.selectAudioOutput === 'function'
|
|
);
|
|
}
|
|
|
|
function sanitizeTimelineText(value) {
|
|
return String(value || '')
|
|
.replace(/\s+/g, ' ')
|
|
.replace(/[,]/g, ';')
|
|
.trim();
|
|
}
|
|
|
|
function getSignalTypeName(type) {
|
|
const normalized = Number(type);
|
|
if (normalized === TYPES.INVITE) return 'invite';
|
|
if (normalized === TYPES.RINGING) return 'ringing';
|
|
if (normalized === TYPES.ACCEPT) return 'accept';
|
|
if (normalized === TYPES.DECLINE_BUSY) return 'decline_busy';
|
|
if (normalized === TYPES.TIMEOUT) return 'timeout';
|
|
if (normalized === TYPES.HANGUP) return 'hangup';
|
|
if (normalized === TYPES.CONNECT_START) return 'connect_start';
|
|
if (normalized === TYPES.OFFER) return 'offer';
|
|
if (normalized === TYPES.ANSWER) return 'answer';
|
|
if (normalized === TYPES.ICE) return 'ice';
|
|
return `type_${String(type || '')}`;
|
|
}
|
|
|
|
function buildConnectStartData(winnerSessionId) {
|
|
return `session=${String(winnerSessionId || '').trim()}`;
|
|
}
|
|
|
|
function normalizeCallMode(mode) {
|
|
const normalized = String(mode || '').trim().toLowerCase();
|
|
if (normalized === CALL_MODE_AUDIO) return CALL_MODE_AUDIO;
|
|
if (normalized === CALL_MODE_INSTANT_VIDEO) return CALL_MODE_INSTANT_VIDEO;
|
|
return CALL_MODE_VIDEO;
|
|
}
|
|
|
|
function getVideoTransportModeForCallMode(mode) {
|
|
return normalizeCallMode(mode) === CALL_MODE_AUDIO ? VIDEO_TRANSPORT_RESERVED : VIDEO_TRANSPORT_SLOT;
|
|
}
|
|
|
|
function isInstantVideoMode(mode) {
|
|
return normalizeCallMode(mode) === CALL_MODE_INSTANT_VIDEO;
|
|
}
|
|
|
|
function isVideoCallMode(mode) {
|
|
const normalized = normalizeCallMode(mode);
|
|
return normalized === CALL_MODE_VIDEO || normalized === CALL_MODE_INSTANT_VIDEO;
|
|
}
|
|
|
|
function buildInviteData({ mode } = {}) {
|
|
return JSON.stringify({
|
|
mode: normalizeCallMode(mode),
|
|
});
|
|
}
|
|
|
|
function parseInviteData(data = '') {
|
|
try {
|
|
const parsed = JSON.parse(String(data || '{}'));
|
|
return {
|
|
mode: normalizeCallMode(parsed?.mode || CALL_MODE_VIDEO),
|
|
};
|
|
} catch {
|
|
return {
|
|
mode: CALL_MODE_VIDEO,
|
|
};
|
|
}
|
|
}
|
|
|
|
function getCallTitleText(mode) {
|
|
if (normalizeCallMode(mode) === CALL_MODE_INSTANT_VIDEO) {
|
|
return t('remaining.call.video_call');
|
|
}
|
|
if (normalizeCallMode(mode) === CALL_MODE_VIDEO) {
|
|
return t('remaining.call.video_call');
|
|
}
|
|
return t('remaining.call.call');
|
|
}
|
|
|
|
function getIncomingCallStatusText(peerLogin, mode) {
|
|
const name = String(peerLogin || '').trim();
|
|
if (normalizeCallMode(mode) === CALL_MODE_INSTANT_VIDEO) {
|
|
return t('remaining.call.incoming_video', { name });
|
|
}
|
|
if (isVideoCallMode(mode)) {
|
|
return t('remaining.call.incoming_video', { name });
|
|
}
|
|
return t('remaining.call.incoming_voice', { name });
|
|
}
|
|
|
|
function parseConnectStartWinnerSessionId(data = '') {
|
|
const raw = String(data || '').trim();
|
|
if (!raw) return '';
|
|
if (raw.startsWith('session=')) return raw.slice('session='.length).trim();
|
|
if (raw.startsWith('winnerSessionId=')) return raw.slice('winnerSessionId='.length).trim();
|
|
return '';
|
|
}
|
|
|
|
function getCallSignalType(type) {
|
|
return CALL_SIGNAL_TYPES[Number(type)] || '';
|
|
}
|
|
|
|
function encodeCallSignalData(callId, type, data = '') {
|
|
return JSON.stringify({
|
|
callId: String(callId || '').trim(),
|
|
type: Number(type),
|
|
data: String(data || ''),
|
|
});
|
|
}
|
|
|
|
function decodeCallSignalData(raw) {
|
|
try {
|
|
const parsed = JSON.parse(String(raw || '{}'));
|
|
return {
|
|
callId: String(parsed?.callId || '').trim(),
|
|
type: Number(parsed?.type),
|
|
data: String(parsed?.data || ''),
|
|
};
|
|
} catch {
|
|
return {
|
|
callId: '',
|
|
type: Number.NaN,
|
|
data: '',
|
|
};
|
|
}
|
|
}
|
|
|
|
function ensureCallTimeline(call) {
|
|
if (!call) return;
|
|
if (!Array.isArray(call.timelineEvents)) call.timelineEvents = [];
|
|
if (!Number.isFinite(call.timelineSeq)) call.timelineSeq = 0;
|
|
if (!Number.isFinite(call.timelineBaseMs) || call.timelineBaseMs <= 0) {
|
|
call.timelineBaseMs = Number(call.startedAtMs || nowMs());
|
|
}
|
|
}
|
|
|
|
function recordCallTimeline(call, stage, details = '', level = 'info') {
|
|
if (!call) return;
|
|
ensureCallTimeline(call);
|
|
const ts = nowMs();
|
|
const deltaMs = Math.max(0, ts - Number(call.timelineBaseMs || ts));
|
|
const cleanStage = sanitizeTimelineText(stage) || 'unknown';
|
|
const cleanDetails = sanitizeTimelineText(details);
|
|
call.timelineSeq += 1;
|
|
call.timelineEvents.push({
|
|
seq: call.timelineSeq,
|
|
ts,
|
|
deltaMs,
|
|
stage: cleanStage,
|
|
details: cleanDetails,
|
|
});
|
|
if (call.timelineEvents.length > MAX_TIMELINE_ENTRIES) {
|
|
call.timelineEvents.splice(0, call.timelineEvents.length - MAX_TIMELINE_ENTRIES);
|
|
}
|
|
addAppLogEntry({
|
|
level,
|
|
source: 'call',
|
|
message: `[${call.callId || '?'}] +${deltaMs}ms ${cleanStage}`,
|
|
details: cleanDetails || buildCallFactsJson(call),
|
|
});
|
|
}
|
|
|
|
function buildTimelineSummary(call) {
|
|
const events = Array.isArray(call?.timelineEvents) ? call.timelineEvents : [];
|
|
if (!events.length) return '';
|
|
return events
|
|
.map((entry) => {
|
|
const head = `+${Number(entry?.deltaMs || 0)}:${sanitizeTimelineText(entry?.stage || '')}`;
|
|
const tail = sanitizeTimelineText(entry?.details || '');
|
|
return tail ? `${head}(${tail})` : head;
|
|
})
|
|
.join('|')
|
|
.slice(0, 1800);
|
|
}
|
|
|
|
function setRemoteSessionId(call, sessionId, reason = '') {
|
|
if (!call) return;
|
|
const next = String(sessionId || '').trim();
|
|
if (!next) return;
|
|
const prev = String(call.remoteSessionId || '').trim();
|
|
if (prev === next) {
|
|
recordCallTimeline(call, 'remote_session_confirmed', `session=${next}; reason=${reason || 'same'}`);
|
|
return;
|
|
}
|
|
call.remoteSessionId = next;
|
|
recordCallTimeline(call, 'remote_session_selected', `from=${prev || '-'}; to=${next}; reason=${reason || 'unknown'}`);
|
|
}
|
|
|
|
function resolveCallPreflightTimeoutMs() {
|
|
const configured = Number(state?.entrySettings?.callPreflightTimeoutMs || 6000);
|
|
return Math.max(1000, Math.min(20000, Number.isFinite(configured) ? configured : 6000));
|
|
}
|
|
|
|
function isSessionReadyForCall() {
|
|
const wsOpen = Boolean(authService?.ws?.ws && authService.ws.ws.readyState === WebSocket.OPEN);
|
|
const hasSession = Boolean(state?.session?.isAuthorized && state?.session?.login && state?.session?.sessionId);
|
|
return wsOpen && hasSession;
|
|
}
|
|
|
|
async function withTimeout(promise, timeoutMs, timeoutMessage = 'timeout') {
|
|
let timerId = 0;
|
|
try {
|
|
return await Promise.race([
|
|
promise,
|
|
new Promise((_, reject) => {
|
|
timerId = window.setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
|
|
}),
|
|
]);
|
|
} finally {
|
|
if (timerId) window.clearTimeout(timerId);
|
|
}
|
|
}
|
|
|
|
async function ensureSessionForCall({ timeoutMs, force = false } = {}) {
|
|
if (!force && isSessionReadyForCall()) return true;
|
|
const login = String(state?.session?.login || '').trim();
|
|
const sessionId = String(state?.session?.sessionId || '').trim();
|
|
if (!login || !sessionId) return false;
|
|
|
|
try {
|
|
await withTimeout(authService.ws.open(), timeoutMs, 'call_preflight_ws_timeout');
|
|
const resumed = await withTimeout(authService.resumeSession(login, sessionId), timeoutMs, 'call_preflight_resume_timeout');
|
|
authorizeSession(resumed);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function makeCallId() {
|
|
return `${Date.now()}${Math.floor(Math.random() * 1_000_000_000)}`;
|
|
}
|
|
|
|
function getCall(callId) {
|
|
return calls.get(callId) || null;
|
|
}
|
|
|
|
function getActiveCall() {
|
|
if (!activeCallId) return null;
|
|
return getCall(activeCallId);
|
|
}
|
|
|
|
function toErrorText(error) {
|
|
return error?.message || String(error || 'unknown');
|
|
}
|
|
|
|
function formatDuration(ms) {
|
|
const totalSec = Math.max(0, Math.round(Number(ms || 0) / 1000));
|
|
const sec = totalSec % 60;
|
|
const totalMin = Math.floor(totalSec / 60);
|
|
const min = totalMin % 60;
|
|
const hours = Math.floor(totalMin / 60);
|
|
if (hours > 0) return `${hours}${t('remaining.call.unit_h')} ${min}${t('remaining.call.unit_m')} ${sec}${t('remaining.call.unit_s')}`;
|
|
if (min > 0) return `${min}${t('remaining.call.unit_m')} ${sec}${t('remaining.call.unit_s')}`;
|
|
return `${sec}${t('remaining.call.unit_s')}`;
|
|
}
|
|
|
|
function isInviteUndelivered(call) {
|
|
const wsDelivered = Number(call?.inviteDelivery?.deliveredWsSessions || 0);
|
|
const pushDelivered = Number(
|
|
call?.inviteDelivery?.deliveredWebPushSessions
|
|
|| call?.inviteDelivery?.deliveredFcmSessions
|
|
|| 0
|
|
);
|
|
return (wsDelivered + pushDelivered) <= 0;
|
|
}
|
|
|
|
function getInviteDeliveredCount(call) {
|
|
const wsDelivered = Number(call?.inviteDelivery?.deliveredWsSessions || 0);
|
|
const pushDelivered = Number(
|
|
call?.inviteDelivery?.deliveredWebPushSessions
|
|
|| call?.inviteDelivery?.deliveredFcmSessions
|
|
|| 0
|
|
);
|
|
return wsDelivered + pushDelivered;
|
|
}
|
|
|
|
function buildOutgoingCallSummaryText(call, summaryCode) {
|
|
if (!call || call.direction !== 'out') return '';
|
|
if (summaryCode === 'completed') {
|
|
return buildDmCallTechBlock({
|
|
status: 'completed',
|
|
durationSec: Math.round(Math.max(0, nowMs() - Number(call.connectedAtMs || call.startedAtMs || nowMs())) / 1000),
|
|
});
|
|
}
|
|
if (summaryCode === 'busy') {
|
|
return buildDmCallTechBlock({ status: 'failed', reason: 'busy' });
|
|
}
|
|
if (summaryCode === 'declined') {
|
|
return buildDmCallTechBlock({ status: 'failed', reason: 'declined' });
|
|
}
|
|
if (summaryCode === 'no_answer') {
|
|
if (isInviteUndelivered(call)) {
|
|
return buildDmCallTechBlock({ status: 'failed', reason: 'offline' });
|
|
}
|
|
return buildDmCallTechBlock({ status: 'failed', reason: 'no_answer' });
|
|
}
|
|
if (summaryCode === 'error') {
|
|
return buildDmCallTechBlock({ status: 'failed', reason: 'connect_failed' });
|
|
}
|
|
return '';
|
|
}
|
|
|
|
async function applyLocalOutgoingDmCopy(peerLogin, result) {
|
|
const localOutgoingBlobB64 = String(result?.localOutgoingBlobB64 || '').trim();
|
|
if (!peerLogin || !localOutgoingBlobB64) return false;
|
|
try {
|
|
const parsed = authService.parseSignedMessageBlob(localOutgoingBlobB64);
|
|
const decrypted = await authService.decryptSignedMessageContent({
|
|
parsed,
|
|
login: state.session.login,
|
|
storagePwd: state.session.storagePwdInMemory,
|
|
});
|
|
addSignedMessageToChat({
|
|
chatId: peerLogin,
|
|
messageKey: String(result?.outgoingKey || parsed?.messageKey || ''),
|
|
baseKey: String(result?.baseKey || result?.localBaseKey || parsed?.baseKey || ''),
|
|
from: 'out',
|
|
text: String(decrypted?.text || ''),
|
|
messageType: Number(parsed?.messageType || 2),
|
|
unread: false,
|
|
rawBlobB64: localOutgoingBlobB64,
|
|
revisionTimeMs: Number(parsed?.revisionTimeMs || 0),
|
|
deleted: Boolean(parsed?.deleted),
|
|
});
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function sendOutgoingCallSummaryDm(call, summaryCode) {
|
|
if (!call || call.direction !== 'out' || !call.peerLogin) return;
|
|
const totalMs = Math.max(0, nowMs() - Number(call.startedAtMs || nowMs()));
|
|
if (totalMs < CALL_SUMMARY_MIN_TOTAL_MS) return;
|
|
const text = buildOutgoingCallSummaryText(call, summaryCode);
|
|
if (!text) return;
|
|
const login = String(state?.session?.login || '').trim();
|
|
const storagePwd = String(state?.session?.storagePwdInMemory || '').trim();
|
|
if (!login || !storagePwd) return;
|
|
try {
|
|
const result = await authService.sendDirectMessage({
|
|
login,
|
|
toLogin: call.peerLogin,
|
|
text,
|
|
storagePwd,
|
|
});
|
|
await applyLocalOutgoingDmCopy(call.peerLogin, result);
|
|
} catch (error) {
|
|
await emitDebug(call, 'warn', 'call_summary_dm_failed', toErrorText(error));
|
|
}
|
|
}
|
|
|
|
function cloneDefaultIceServers() {
|
|
return DEFAULT_ICE_SERVERS.map((row) => ({ ...row }));
|
|
}
|
|
|
|
function parseIceUrls(raw) {
|
|
if (Array.isArray(raw)) {
|
|
return raw
|
|
.map((item) => String(item || '').trim())
|
|
.filter((item) => item.length > 0);
|
|
}
|
|
const single = String(raw || '').trim();
|
|
if (!single) return [];
|
|
return [single];
|
|
}
|
|
|
|
function uniqueUrls(urls = []) {
|
|
const out = [];
|
|
const seen = new Set();
|
|
urls.forEach((url) => {
|
|
const clean = String(url || '').trim();
|
|
if (!clean || seen.has(clean)) return;
|
|
seen.add(clean);
|
|
out.push(clean);
|
|
});
|
|
return out;
|
|
}
|
|
|
|
function parseTurnHostFromUrl(rawUrl) {
|
|
const value = String(rawUrl || '').trim();
|
|
if (!value) return '';
|
|
const noProto = value.replace(/^turns?:/i, '');
|
|
const noQuery = noProto.split('?')[0];
|
|
const noPath = noQuery.split('/')[0];
|
|
const hostPort = noPath.replace(/^\/\//, '').trim();
|
|
if (!hostPort) return '';
|
|
if (hostPort.startsWith('[')) {
|
|
const end = hostPort.indexOf(']');
|
|
if (end > 1) return hostPort.slice(1, end);
|
|
return '';
|
|
}
|
|
const idx = hostPort.indexOf(':');
|
|
return (idx >= 0 ? hostPort.slice(0, idx) : hostPort).trim();
|
|
}
|
|
|
|
async function resolveIceServers(call) {
|
|
try {
|
|
const payload = await authService.getCallIceConfig();
|
|
const stunUrls = uniqueUrls(parseIceUrls(payload?.stunUrls));
|
|
const turnUrls = uniqueUrls(parseIceUrls(payload?.turnUrls));
|
|
const turnUsername = String(payload?.turnUsername || '').trim();
|
|
const turnPassword = String(payload?.turnPassword || '').trim();
|
|
const turnServers = Array.isArray(payload?.turnServers) ? payload.turnServers : [];
|
|
|
|
const turnHostSet = new Set();
|
|
const iceServers = [];
|
|
if (stunUrls.length > 0) {
|
|
iceServers.push({ urls: stunUrls.length === 1 ? stunUrls[0] : stunUrls });
|
|
}
|
|
if (turnServers.length > 0) {
|
|
turnServers.forEach((item) => {
|
|
const urls = uniqueUrls(parseIceUrls(item?.urls));
|
|
const username = String(item?.username || '').trim();
|
|
const password = String(item?.password || '').trim();
|
|
if (urls.length === 0 || !username || !password) return;
|
|
urls.forEach((url) => {
|
|
const host = parseTurnHostFromUrl(url);
|
|
if (host) turnHostSet.add(host);
|
|
});
|
|
iceServers.push({
|
|
urls: urls.length === 1 ? urls[0] : urls,
|
|
username,
|
|
credential: password,
|
|
});
|
|
});
|
|
} else if (turnUrls.length > 0 && turnUsername && turnPassword) {
|
|
turnUrls.forEach((url) => {
|
|
const host = parseTurnHostFromUrl(url);
|
|
if (host) turnHostSet.add(host);
|
|
});
|
|
iceServers.push({
|
|
urls: turnUrls.length === 1 ? turnUrls[0] : turnUrls,
|
|
username: turnUsername,
|
|
credential: turnPassword,
|
|
});
|
|
}
|
|
|
|
if (iceServers.length === 0) {
|
|
await emitDebug(call, 'warn', 'call_ice_empty_from_server', 'using_default_stun');
|
|
return cloneDefaultIceServers();
|
|
}
|
|
if (call) {
|
|
call.turnHostsConfigured = Array.from(turnHostSet);
|
|
}
|
|
await emitDebug(call, 'info', 'call_ice_loaded_from_server', `stun=${stunUrls.length}; turnEntries=${Math.max(0, iceServers.length - (stunUrls.length > 0 ? 1 : 0))}`);
|
|
return iceServers;
|
|
} catch (error) {
|
|
await emitDebug(call, 'warn', 'call_ice_load_failed', toErrorText(error));
|
|
return cloneDefaultIceServers();
|
|
}
|
|
}
|
|
|
|
async function collectIceCandidateAnalytics(call) {
|
|
const pc = call?.pc;
|
|
if (!pc || typeof pc.getStats !== 'function') return {};
|
|
try {
|
|
const stats = await pc.getStats();
|
|
const localCounts = { host: 0, srflx: 0, relay: 0, prflx: 0, other: 0 };
|
|
const remoteCounts = { host: 0, srflx: 0, relay: 0, prflx: 0, other: 0 };
|
|
const relayLocalAddresses = new Set();
|
|
const relayRemoteAddresses = new Set();
|
|
const configuredHosts = new Set((call?.turnHostsConfigured || []).map((v) => String(v || '').trim()).filter(Boolean));
|
|
const matchedConfiguredHosts = new Set();
|
|
let succeededPairsCount = 0;
|
|
let succeededPairsWithRelayCount = 0;
|
|
|
|
const bump = (bucket, rawType) => {
|
|
const type = String(rawType || '').trim().toLowerCase();
|
|
if (!type) bucket.other += 1;
|
|
else if (Object.prototype.hasOwnProperty.call(bucket, type)) bucket[type] += 1;
|
|
else bucket.other += 1;
|
|
};
|
|
const hostOf = (candidate) => {
|
|
const raw = String(candidate?.ip || candidate?.address || '').trim();
|
|
if (!raw) return '';
|
|
if (raw.startsWith('[')) {
|
|
const end = raw.indexOf(']');
|
|
if (end > 1) return raw.slice(1, end);
|
|
}
|
|
return raw;
|
|
};
|
|
|
|
stats.forEach((report) => {
|
|
if (!report || report.type !== 'local-candidate') return;
|
|
bump(localCounts, report.candidateType);
|
|
if (String(report.candidateType || '').toLowerCase() === 'relay') {
|
|
const addr = String(report.ip || report.address || '');
|
|
const port = String(report.port || '');
|
|
relayLocalAddresses.add(port ? `${addr}:${port}` : addr);
|
|
const host = hostOf(report);
|
|
if (host && configuredHosts.has(host)) matchedConfiguredHosts.add(host);
|
|
}
|
|
});
|
|
stats.forEach((report) => {
|
|
if (!report || report.type !== 'remote-candidate') return;
|
|
bump(remoteCounts, report.candidateType);
|
|
if (String(report.candidateType || '').toLowerCase() === 'relay') {
|
|
const addr = String(report.ip || report.address || '');
|
|
const port = String(report.port || '');
|
|
relayRemoteAddresses.add(port ? `${addr}:${port}` : addr);
|
|
}
|
|
});
|
|
stats.forEach((report) => {
|
|
if (!report || report.type !== 'candidate-pair') return;
|
|
const state = String(report.state || '').toLowerCase();
|
|
const ok = report.selected === true || (report.nominated === true && state === 'succeeded') || state === 'succeeded';
|
|
if (!ok) return;
|
|
succeededPairsCount += 1;
|
|
const local = report.localCandidateId && typeof stats.get === 'function' ? stats.get(report.localCandidateId) : null;
|
|
const remote = report.remoteCandidateId && typeof stats.get === 'function' ? stats.get(report.remoteCandidateId) : null;
|
|
const lt = String(local?.candidateType || '').toLowerCase();
|
|
const rt = String(remote?.candidateType || '').toLowerCase();
|
|
if (lt === 'relay' || rt === 'relay') succeededPairsWithRelayCount += 1;
|
|
});
|
|
|
|
return {
|
|
localCandidatesHost: localCounts.host,
|
|
localCandidatesSrflx: localCounts.srflx,
|
|
localCandidatesRelay: localCounts.relay,
|
|
localCandidatesPrflx: localCounts.prflx,
|
|
localCandidatesOther: localCounts.other,
|
|
remoteCandidatesHost: remoteCounts.host,
|
|
remoteCandidatesSrflx: remoteCounts.srflx,
|
|
remoteCandidatesRelay: remoteCounts.relay,
|
|
remoteCandidatesPrflx: remoteCounts.prflx,
|
|
remoteCandidatesOther: remoteCounts.other,
|
|
relayLocalCandidatesFound: relayLocalAddresses.size,
|
|
relayRemoteCandidatesFound: relayRemoteAddresses.size,
|
|
relayLocalCandidatesAddresses: Array.from(relayLocalAddresses).join('|'),
|
|
relayRemoteCandidatesAddresses: Array.from(relayRemoteAddresses).join('|'),
|
|
configuredTurnHosts: Array.from(configuredHosts).join('|'),
|
|
configuredTurnHostsCount: configuredHosts.size,
|
|
reachableTurnHostsCount: matchedConfiguredHosts.size,
|
|
reachableTurnHosts: Array.from(matchedConfiguredHosts).join('|'),
|
|
turnConfiguredButNotReachedHosts: Array.from(configuredHosts).filter((host) => !matchedConfiguredHosts.has(host)).join('|'),
|
|
succeededCandidatePairsCount: succeededPairsCount,
|
|
succeededCandidatePairsWithRelayCount: succeededPairsWithRelayCount,
|
|
};
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
function ensureAudioContext() {
|
|
if (audioContext) return audioContext;
|
|
const Ctx = window.AudioContext || window.webkitAudioContext;
|
|
if (!Ctx) return null;
|
|
audioContext = new Ctx();
|
|
return audioContext;
|
|
}
|
|
|
|
function playBeep(freq = 440, durationMs = 120, gainValue = 0.08) {
|
|
const ctx = ensureAudioContext();
|
|
if (!ctx) return;
|
|
if (ctx.state === 'suspended') {
|
|
void ctx.resume().catch(() => {});
|
|
}
|
|
const osc = ctx.createOscillator();
|
|
const gain = ctx.createGain();
|
|
osc.type = 'sine';
|
|
osc.frequency.value = Number(freq) || 440;
|
|
gain.gain.value = gainValue;
|
|
osc.connect(gain);
|
|
gain.connect(ctx.destination);
|
|
const now = ctx.currentTime;
|
|
osc.start(now);
|
|
osc.stop(now + Math.max(0.03, durationMs / 1000));
|
|
}
|
|
|
|
function stopTone() {
|
|
if (toneTimerId) {
|
|
clearInterval(toneTimerId);
|
|
toneTimerId = null;
|
|
}
|
|
toneName = '';
|
|
toneFlip = false;
|
|
}
|
|
|
|
function startTone(nextToneName) {
|
|
if (!nextToneName) {
|
|
stopTone();
|
|
return;
|
|
}
|
|
if (toneName === nextToneName) return;
|
|
stopTone();
|
|
toneName = nextToneName;
|
|
if (nextToneName === 'searching') {
|
|
toneTimerId = window.setInterval(() => {
|
|
toneFlip = !toneFlip;
|
|
playBeep(toneFlip ? 920 : 760, 120, 0.07);
|
|
}, 420);
|
|
return;
|
|
}
|
|
if (nextToneName === 'ringback') {
|
|
playBeep(425, 900, 0.08);
|
|
toneTimerId = window.setInterval(() => {
|
|
playBeep(425, 900, 0.08);
|
|
}, 4000);
|
|
return;
|
|
}
|
|
if (nextToneName === 'incoming') {
|
|
const hit = () => {
|
|
playBeep(830, 180, 0.09);
|
|
window.setTimeout(() => playBeep(680, 180, 0.09), 240);
|
|
};
|
|
hit();
|
|
toneTimerId = window.setInterval(hit, 2000);
|
|
}
|
|
}
|
|
|
|
function getCallStateSnapshot() {
|
|
const call = getActiveCall();
|
|
if (!call) return null;
|
|
if (call.localUiDismissed) return null;
|
|
const callPhase = String(call.phase || '').trim();
|
|
const localVideoTracks = call.localStream?.getVideoTracks?.() || [];
|
|
const remoteVideoTracks = call.remoteMediaStream?.getVideoTracks?.() || [];
|
|
const canToggleSpeaker = Boolean(
|
|
callPhase !== 'incoming'
|
|
&& callPhase !== 'ended'
|
|
&& canRouteAudioOutputInBrowser()
|
|
&& call.remoteAudio
|
|
);
|
|
const canToggleCamera = Boolean(
|
|
callPhase !== 'incoming'
|
|
&& callPhase !== 'ended'
|
|
&& navigator?.mediaDevices?.getUserMedia
|
|
&& call.pc
|
|
);
|
|
return {
|
|
callId: call.callId,
|
|
peerLogin: call.peerLogin || '',
|
|
titleText: getCallTitleText(call.callMode),
|
|
callMode: normalizeCallMode(call.callMode),
|
|
direction: call.direction || 'out',
|
|
phase: callPhase,
|
|
statusText: call.statusText || '',
|
|
startedAtMs: Number(call.startedAtMs || 0),
|
|
connectedAtMs: Number(call.connectedAtMs || 0),
|
|
muted: Boolean(call.muted),
|
|
cameraEnabled: Boolean(call.cameraEnabled),
|
|
speakerEnabled: Boolean(call.speakerEnabled),
|
|
canToggleSpeaker,
|
|
canToggleCamera,
|
|
canAnswer: callPhase === 'incoming',
|
|
canDecline: callPhase === 'incoming',
|
|
canHangup: callPhase !== 'ended' && callPhase !== 'incoming',
|
|
canMute: callPhase === 'active' || callPhase === 'connecting' || callPhase === 'ringing' || callPhase === 'reconnecting',
|
|
hasLocalVideo: Boolean(
|
|
call.cameraEnabled
|
|
&& call.localVideoTrack
|
|
&& call.localVideoTrack.readyState === 'live'
|
|
&& call.localVideoTrack.enabled !== false
|
|
),
|
|
hasRemoteVideo: remoteVideoTracks.some((track) => track?.readyState === 'live' && !track?.muted),
|
|
localPreviewStream: call.cameraEnabled ? (call.localStream || null) : null,
|
|
remoteMediaStream: call.remoteMediaStream || null,
|
|
};
|
|
}
|
|
|
|
function notifyCallState() {
|
|
const snapshot = getCallStateSnapshot();
|
|
callStateListeners.forEach((listener) => {
|
|
try {
|
|
listener(snapshot);
|
|
} catch {}
|
|
});
|
|
}
|
|
|
|
function dismissCallUiLocally(call) {
|
|
if (!call) return;
|
|
call.localUiDismissed = true;
|
|
notifyCallState();
|
|
}
|
|
|
|
function setStatus(call, statusText, phase = '') {
|
|
if (!call) return;
|
|
call.statusText = String(statusText || '').trim();
|
|
if (phase) {
|
|
call.phase = String(phase || '').trim();
|
|
}
|
|
if (call.phase === 'searching') startTone('searching');
|
|
else if (call.phase === 'ringing') startTone('ringback');
|
|
else if (call.phase === 'incoming') startTone('incoming');
|
|
else stopTone();
|
|
|
|
recordCallTimeline(call, 'status', `phase=${call.phase || ''}; text=${call.statusText || ''}`);
|
|
void emitDebug(call, 'info', `call_status: ${call.statusText}`, `callId=${call.callId}`);
|
|
notifyCallState();
|
|
}
|
|
|
|
function buildActiveStatusText(call) {
|
|
const route = String(call?.connectionRouteLabel || '').trim();
|
|
const videoSlotMarker = call?.videoSlotReady ? ' +' : '';
|
|
return route ? t('remaining.call.active_route', { route, videoSlotMarker }) : t('remaining.call.call_in_progress');
|
|
}
|
|
|
|
function refreshVideoSlotReady(call) {
|
|
if (!call?.pc) return false;
|
|
const localSdp = String(call.pc.localDescription?.sdp || '');
|
|
const remoteSdp = String(call.pc.remoteDescription?.sdp || '');
|
|
const hasVideoInLocal = localSdp.includes('\nm=video') || localSdp.startsWith('m=video');
|
|
const hasVideoInRemote = remoteSdp.includes('\nm=video') || remoteSdp.startsWith('m=video');
|
|
call.videoSlotReady = Boolean(hasVideoInLocal && hasVideoInRemote && call.videoTransceiver);
|
|
return call.videoSlotReady;
|
|
}
|
|
|
|
function hasVideoSectionInSdp(sdp = '') {
|
|
const text = String(sdp || '');
|
|
return text.includes('\nm=video') || text.startsWith('m=video');
|
|
}
|
|
|
|
function setActiveStatus(call) {
|
|
setStatus(call, buildActiveStatusText(call), 'active');
|
|
}
|
|
|
|
function toIsoTs(ts) {
|
|
const n = Number(ts || 0);
|
|
if (!Number.isFinite(n) || n <= 0) return '';
|
|
try { return new Date(n).toISOString(); } catch { return ''; }
|
|
}
|
|
|
|
function buildCallFactsJson(call, extra = {}) {
|
|
const pc = call?.pc || null;
|
|
const facts = {
|
|
callId: call?.callId || '',
|
|
peerLogin: call?.peerLogin || '',
|
|
remoteSessionId: call?.remoteSessionId || '',
|
|
direction: call?.direction || '',
|
|
phase: call?.phase || '',
|
|
statusText: call?.statusText || '',
|
|
startedAtMs: Number(call?.startedAtMs || 0),
|
|
startedAtIso: toIsoTs(call?.startedAtMs),
|
|
connectedAtMs: Number(call?.connectedAtMs || 0),
|
|
connectedAtIso: toIsoTs(call?.connectedAtMs),
|
|
routeLabel: call?.connectionRouteLabel || '',
|
|
routeDetails: call?.connectionRouteDetails || '',
|
|
pcConnectionState: pc?.connectionState || '',
|
|
pcIceConnectionState: pc?.iceConnectionState || '',
|
|
pcSignalingState: pc?.signalingState || '',
|
|
hasLocalStream: Boolean(call?.localStream),
|
|
localAudioTracksCount: call?.localStream?.getAudioTracks?.()?.length || 0,
|
|
localVideoTracksCount: call?.localStream?.getVideoTracks?.()?.length || 0,
|
|
timeline: buildTimelineSummary(call),
|
|
...extra,
|
|
};
|
|
try {
|
|
return JSON.stringify(facts);
|
|
} catch {
|
|
return JSON.stringify({ callId: call?.callId || '', serializeError: true });
|
|
}
|
|
}
|
|
|
|
function buildCallFactsLine(call, extra = {}) {
|
|
const pc = call?.pc || null;
|
|
const facts = {
|
|
callId: call?.callId || '',
|
|
peerLogin: call?.peerLogin || '',
|
|
remoteSessionId: call?.remoteSessionId || '',
|
|
direction: call?.direction || '',
|
|
phase: call?.phase || '',
|
|
statusText: call?.statusText || '',
|
|
startedAtMs: Number(call?.startedAtMs || 0),
|
|
startedAtIso: toIsoTs(call?.startedAtMs),
|
|
connectedAtMs: Number(call?.connectedAtMs || 0),
|
|
connectedAtIso: toIsoTs(call?.connectedAtMs),
|
|
routeLabel: call?.connectionRouteLabel || '',
|
|
routeDetails: call?.connectionRouteDetails || '',
|
|
pcConnectionState: pc?.connectionState || '',
|
|
pcIceConnectionState: pc?.iceConnectionState || '',
|
|
pcSignalingState: pc?.signalingState || '',
|
|
hasLocalStream: Boolean(call?.localStream),
|
|
localAudioTracksCount: call?.localStream?.getAudioTracks?.()?.length || 0,
|
|
localVideoTracksCount: call?.localStream?.getVideoTracks?.()?.length || 0,
|
|
localTrackStates: summarizeMediaSnapshot(buildMediaSnapshot(call)),
|
|
timeline: buildTimelineSummary(call),
|
|
...extra,
|
|
};
|
|
return Object.entries(facts)
|
|
.map(([k, v]) => `${k}=${String(v ?? '').replace(/,/g, ';')}`)
|
|
.join(', ');
|
|
}
|
|
|
|
function buildMediaSnapshot(call) {
|
|
const localStream = call?.localStream || null;
|
|
const localTracks = localStream?.getTracks?.() || [];
|
|
const remoteAudio = call?.remoteAudio || null;
|
|
const remoteStream = call?.remoteMediaStream || remoteAudio?.srcObject || null;
|
|
const remoteTracks = remoteStream?.getTracks?.() || [];
|
|
return {
|
|
hasLocalStream: Boolean(localStream),
|
|
localTrackCount: localTracks.length,
|
|
localAudioTracksCount: localStream?.getAudioTracks?.()?.length || 0,
|
|
localVideoTracksCount: localStream?.getVideoTracks?.()?.length || 0,
|
|
localTrackStates: localTracks.map((track) => ({
|
|
kind: String(track?.kind || ''),
|
|
enabled: Boolean(track?.enabled),
|
|
muted: Boolean(track?.muted),
|
|
readyState: String(track?.readyState || ''),
|
|
label: String(track?.label || ''),
|
|
})),
|
|
hasRemoteAudio: Boolean(remoteAudio),
|
|
hasRemoteAudioSrcObject: Boolean(remoteStream),
|
|
remoteTrackCount: remoteTracks.length,
|
|
remoteTrackStates: remoteTracks.map((track) => ({
|
|
kind: String(track?.kind || ''),
|
|
enabled: Boolean(track?.enabled),
|
|
muted: Boolean(track?.muted),
|
|
readyState: String(track?.readyState || ''),
|
|
label: String(track?.label || ''),
|
|
})),
|
|
};
|
|
}
|
|
|
|
function summarizeMediaSnapshot(snapshot) {
|
|
if (!snapshot) return '';
|
|
const localSummary = Array.isArray(snapshot.localTrackStates)
|
|
? snapshot.localTrackStates.map((track) => (
|
|
`${track.kind}:${track.readyState}:${track.enabled ? 'on' : 'off'}:${track.muted ? 'muted' : 'live'}`
|
|
)).join('|')
|
|
: '';
|
|
const remoteSummary = Array.isArray(snapshot.remoteTrackStates)
|
|
? snapshot.remoteTrackStates.map((track) => (
|
|
`${track.kind}:${track.readyState}:${track.enabled ? 'on' : 'off'}:${track.muted ? 'muted' : 'live'}`
|
|
)).join('|')
|
|
: '';
|
|
return [
|
|
`localStream=${snapshot.hasLocalStream ? 1 : 0}`,
|
|
`localTracks=${Number(snapshot.localTrackCount || 0)}`,
|
|
`localAudio=${Number(snapshot.localAudioTracksCount || 0)}`,
|
|
`localVideo=${Number(snapshot.localVideoTracksCount || 0)}`,
|
|
`localStates=${localSummary || '-'}`,
|
|
`remoteAudio=${snapshot.hasRemoteAudio ? 1 : 0}`,
|
|
`remoteSrc=${snapshot.hasRemoteAudioSrcObject ? 1 : 0}`,
|
|
`remoteTracks=${Number(snapshot.remoteTrackCount || 0)}`,
|
|
`remoteStates=${remoteSummary || '-'}`,
|
|
].join(';');
|
|
}
|
|
|
|
function getCallDiagnosticsContext(call) {
|
|
const pc = call?.pc || null;
|
|
const nav = typeof navigator !== 'undefined' ? navigator : null;
|
|
const conn = nav?.connection || nav?.mozConnection || nav?.webkitConnection || null;
|
|
const permissionsApiAvailable = typeof nav?.permissions?.query === 'function';
|
|
const mediaDevicesAvailable = Boolean(nav?.mediaDevices?.getUserMedia);
|
|
const online = typeof nav?.onLine === 'boolean' ? nav.onLine : null;
|
|
const visibilityState = typeof document !== 'undefined' ? String(document.visibilityState || '') : '';
|
|
const pageFocused = typeof document !== 'undefined' && typeof document.hasFocus === 'function'
|
|
? Boolean(document.hasFocus())
|
|
: false;
|
|
const localTracks = call?.localStream?.getTracks?.() || [];
|
|
const localAudioTracks = call?.localStream?.getAudioTracks?.() || [];
|
|
const localVideoTracks = call?.localStream?.getVideoTracks?.() || [];
|
|
const enabledLocalAudioTracks = localAudioTracks.filter((track) => track?.enabled).length;
|
|
const enabledLocalVideoTracks = localVideoTracks.filter((track) => track?.enabled).length;
|
|
const transceiversCount = pc?.getTransceivers?.()?.length || 0;
|
|
const sendersCount = pc?.getSenders?.()?.length || 0;
|
|
const receiversCount = pc?.getReceivers?.()?.length || 0;
|
|
const iceGatheringState = pc?.iceGatheringState || '';
|
|
const currentLocalDescType = pc?.localDescription?.type || '';
|
|
const currentRemoteDescType = pc?.remoteDescription?.type || '';
|
|
const mediaSnapshot = buildMediaSnapshot(call);
|
|
|
|
return {
|
|
remoteSessionIdPresent: Boolean(call?.remoteSessionId),
|
|
callExistsInStore: calls.has(String(call?.callId || '')),
|
|
browserOnline: online === null ? '' : String(online),
|
|
documentVisibilityState: visibilityState,
|
|
pageFocused,
|
|
userAgent: typeof nav?.userAgent === 'string' ? nav.userAgent : '',
|
|
platform: typeof nav?.platform === 'string' ? nav.platform : '',
|
|
language: typeof nav?.language === 'string' ? nav.language : '',
|
|
permissionsApiAvailable,
|
|
mediaDevicesApiAvailable: mediaDevicesAvailable,
|
|
connectionType: String(conn?.type || ''),
|
|
effectiveConnectionType: String(conn?.effectiveType || ''),
|
|
networkRttMs: Number(conn?.rtt || 0),
|
|
networkDownlinkMbps: Number(conn?.downlink || 0),
|
|
saveData: conn?.saveData === true,
|
|
localTrackCount: localTracks.length,
|
|
localAudioTracksCount: localAudioTracks.length,
|
|
localAudioTracksEnabledCount: enabledLocalAudioTracks,
|
|
localAudioTrackLabels: localAudioTracks.map((t) => String(t?.label || '')).join('|'),
|
|
localVideoTracksCount: localVideoTracks.length,
|
|
localVideoTracksEnabledCount: enabledLocalVideoTracks,
|
|
localVideoTrackLabels: localVideoTracks.map((t) => String(t?.label || '')).join('|'),
|
|
localTrackStates: summarizeMediaSnapshot(mediaSnapshot),
|
|
hasPeerConnection: Boolean(pc),
|
|
pcConnectionState: pc?.connectionState || '',
|
|
pcIceConnectionState: pc?.iceConnectionState || '',
|
|
pcIceGatheringState: iceGatheringState,
|
|
pcSignalingState: pc?.signalingState || '',
|
|
pcCanTrickleIceCandidates: pc?.canTrickleIceCandidates === null || pc?.canTrickleIceCandidates === undefined
|
|
? ''
|
|
: String(pc?.canTrickleIceCandidates),
|
|
localDescriptionType: currentLocalDescType,
|
|
remoteDescriptionType: currentRemoteDescType,
|
|
pcTransceiversCount: transceiversCount,
|
|
pcSendersCount: sendersCount,
|
|
pcReceiversCount: receiversCount,
|
|
};
|
|
}
|
|
|
|
async function sendCallDeliveryReport(call, eventType, eventCode, reason = '', extraFacts = {}) {
|
|
if (!call || !authService || typeof authService.sendCallDeliveryReport !== 'function') return;
|
|
try {
|
|
const diagnostics = getCallDiagnosticsContext(call);
|
|
const valueLine = buildCallFactsLine(call, {
|
|
eventType: String(eventType || '').trim(),
|
|
eventCode: String(eventCode || '').trim(),
|
|
reason: String(reason || '').trim(),
|
|
reportedAtMs: nowMs(),
|
|
reportedAtIso: toIsoTs(nowMs()),
|
|
timelineEntriesCount: Array.isArray(call?.timelineEvents) ? call.timelineEvents.length : 0,
|
|
...diagnostics,
|
|
...extraFacts,
|
|
});
|
|
await authService.sendCallDeliveryReport({
|
|
type: String(eventType || '').trim(),
|
|
value: valueLine,
|
|
});
|
|
} catch {}
|
|
}
|
|
|
|
function cleanupTimers(call) {
|
|
if (call.timers?.ack10s) clearTimeout(call.timers.ack10s);
|
|
if (call.timers?.total35s) clearTimeout(call.timers.total35s);
|
|
if (call.timers?.incoming20s) clearTimeout(call.timers.incoming20s);
|
|
if (call.timers?.incomingConnect20s) clearTimeout(call.timers.incomingConnect20s);
|
|
if (call.timers?.transportProbe) clearInterval(call.timers.transportProbe);
|
|
call.timers.transportProbe = null;
|
|
}
|
|
|
|
function scheduleOutgoingAckTimeout(call) {
|
|
if (!call?.timers) return;
|
|
if (call.timers.ack10s) {
|
|
clearTimeout(call.timers.ack10s);
|
|
call.timers.ack10s = null;
|
|
}
|
|
const deliveredCount = getInviteDeliveredCount(call);
|
|
const timeoutMs = deliveredCount > 0
|
|
? OUTGOING_DELIVERED_NO_ACK_TIMEOUT_MS
|
|
: OUTGOING_NO_ACK_TIMEOUT_MS;
|
|
const debugReason = deliveredCount > 0 ? 'no_ack_after_delivery_25s' : 'no_ack_10s';
|
|
recordCallTimeline(call, 'ack_timeout_scheduled', `timeoutMs=${timeoutMs}; delivered=${deliveredCount}; reason=${debugReason}`);
|
|
call.timers.ack10s = setTimeout(() => {
|
|
if (!calls.has(call.callId)) return;
|
|
if (call.phase === 'searching' || call.phase === 'ringing') {
|
|
recordCallTimeline(call, 'ack_timeout_fired', `phase=${call.phase || ''}; reason=${debugReason}`, 'warn');
|
|
void finalizeCall(call, { localReasonCode: 'no_answer', debugReason });
|
|
}
|
|
}, timeoutMs);
|
|
}
|
|
|
|
function scheduleIncomingConnectTimeout(call) {
|
|
if (!call?.timers) return;
|
|
if (call.timers.incomingConnect20s) {
|
|
clearTimeout(call.timers.incomingConnect20s);
|
|
}
|
|
recordCallTimeline(call, 'incoming_connect_timeout_scheduled', `timeoutMs=${INCOMING_CONNECT_TIMEOUT_MS}`);
|
|
call.timers.incomingConnect20s = setTimeout(() => {
|
|
if (!calls.has(call.callId)) return;
|
|
if (call.phase !== 'connecting') return;
|
|
recordCallTimeline(call, 'incoming_connect_timeout_fired', `phase=${call.phase || ''}`, 'warn');
|
|
void finalizeCall(call, {
|
|
localReasonCode: 'no_answer',
|
|
debugReason: 'incoming_connect_timeout_20s',
|
|
});
|
|
}, INCOMING_CONNECT_TIMEOUT_MS);
|
|
}
|
|
|
|
async function flushPendingIceCandidates(call) {
|
|
if (!call?.pc) return;
|
|
const pending = Array.isArray(call.pendingRemoteIceCandidates) ? call.pendingRemoteIceCandidates : [];
|
|
if (!pending.length) return;
|
|
call.pendingRemoteIceCandidates = [];
|
|
for (const candidate of pending) {
|
|
try {
|
|
await call.pc.addIceCandidate(new RTCIceCandidate(candidate));
|
|
await emitDebug(call, 'info', 'ice_processed_from_queue', 'candidate added');
|
|
} catch (error) {
|
|
await emitDebug(call, 'warn', 'ice_process_failed_from_queue', toErrorText(error));
|
|
}
|
|
}
|
|
}
|
|
|
|
async function closeMedia(call) {
|
|
const pc = call?.pc || null;
|
|
const beforeSnapshot = buildMediaSnapshot(call);
|
|
recordCallTimeline(call, 'media_close_begin', summarizeMediaSnapshot(beforeSnapshot));
|
|
try {
|
|
const senders = pc?.getSenders?.() || [];
|
|
senders.forEach((sender) => {
|
|
try {
|
|
if (typeof sender?.replaceTrack === 'function') sender.replaceTrack(null);
|
|
} catch {}
|
|
});
|
|
} catch {}
|
|
try {
|
|
const transceivers = pc?.getTransceivers?.() || [];
|
|
transceivers.forEach((tr) => {
|
|
try { tr?.stop?.(); } catch {}
|
|
});
|
|
} catch {}
|
|
try {
|
|
if (pc) {
|
|
pc.ontrack = null;
|
|
pc.onicecandidate = null;
|
|
pc.onconnectionstatechange = null;
|
|
pc.oniceconnectionstatechange = null;
|
|
pc.onsignalingstatechange = null;
|
|
pc.onicegatheringstatechange = null;
|
|
}
|
|
} catch {}
|
|
try {
|
|
call.localStream?.getTracks?.()?.forEach((track) => {
|
|
try { track.enabled = false; } catch {}
|
|
try { track.stop(); } catch {}
|
|
});
|
|
} catch {}
|
|
try {
|
|
if (call.remoteAudio) {
|
|
const remoteTracks = call.remoteMediaStream?.getTracks?.() || call.remoteAudio.srcObject?.getTracks?.() || [];
|
|
remoteTracks.forEach((track) => {
|
|
try { track.enabled = false; } catch {}
|
|
try { track.stop(); } catch {}
|
|
});
|
|
try { call.remoteAudio.pause?.(); } catch {}
|
|
try { call.remoteAudio.srcObject = null; } catch {}
|
|
try { call.remoteAudio.removeAttribute?.('src'); } catch {}
|
|
try { call.remoteAudio.load?.(); } catch {}
|
|
call.remoteAudio = null;
|
|
}
|
|
} catch {}
|
|
try { pc?.close?.(); } catch {}
|
|
call.pc = null;
|
|
call.localStream = null;
|
|
call.localVideoTrack = null;
|
|
call.videoSender = null;
|
|
call.remoteMediaStream = null;
|
|
call.audioSenders = [];
|
|
call.connectionRouteLabel = '';
|
|
call.connectionRouteDetails = '';
|
|
call.pendingRemoteIceCandidates = [];
|
|
const afterSnapshot = buildMediaSnapshot(call);
|
|
recordCallTimeline(call, 'media_close_end', summarizeMediaSnapshot(afterSnapshot));
|
|
await emitDebug(
|
|
call,
|
|
'info',
|
|
'media_closed',
|
|
`before=${summarizeMediaSnapshot(beforeSnapshot)} | after=${summarizeMediaSnapshot(afterSnapshot)}`,
|
|
);
|
|
}
|
|
|
|
function stopReconnectFlow(call) {
|
|
if (!call?.timers) return;
|
|
if (call.timers.reconnectStep) {
|
|
clearTimeout(call.timers.reconnectStep);
|
|
call.timers.reconnectStep = null;
|
|
}
|
|
if (call.timers.reconnectDeadline) {
|
|
clearTimeout(call.timers.reconnectDeadline);
|
|
call.timers.reconnectDeadline = null;
|
|
}
|
|
call.reconnectInProgress = false;
|
|
call.reconnectAttempts = 0;
|
|
}
|
|
|
|
async function detectConnectionRoute(call) {
|
|
const pc = call?.pc;
|
|
if (!pc || typeof pc.getStats !== 'function') {
|
|
return { label: '', details: '', localIp: '', remoteIp: '', turnCandidateAddress: '' };
|
|
}
|
|
try {
|
|
const stats = await pc.getStats();
|
|
let selectedPair = null;
|
|
|
|
stats.forEach((report) => {
|
|
if (selectedPair) return;
|
|
if (report.type !== 'transport') return;
|
|
if (!report.selectedCandidatePairId) return;
|
|
const pair = typeof stats.get === 'function' ? stats.get(report.selectedCandidatePairId) : null;
|
|
if (pair) selectedPair = pair;
|
|
});
|
|
|
|
if (!selectedPair) {
|
|
stats.forEach((report) => {
|
|
if (selectedPair) return;
|
|
if (report.type === 'candidate-pair' && report.selected) selectedPair = report;
|
|
});
|
|
}
|
|
|
|
if (!selectedPair) {
|
|
stats.forEach((report) => {
|
|
if (selectedPair) return;
|
|
if (report.type === 'candidate-pair' && report.nominated && report.state === 'succeeded') {
|
|
selectedPair = report;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (!selectedPair) return { label: '', details: '', localIp: '', remoteIp: '', turnCandidateAddress: '' };
|
|
|
|
const local = selectedPair.localCandidateId && typeof stats.get === 'function'
|
|
? stats.get(selectedPair.localCandidateId)
|
|
: null;
|
|
const remote = selectedPair.remoteCandidateId && typeof stats.get === 'function'
|
|
? stats.get(selectedPair.remoteCandidateId)
|
|
: null;
|
|
|
|
const localType = String(local?.candidateType || '').trim().toLowerCase();
|
|
const remoteType = String(remote?.candidateType || '').trim().toLowerCase();
|
|
const localIp = String(local?.ip || local?.address || '');
|
|
const remoteIp = String(remote?.ip || remote?.address || '');
|
|
const localPort = String(local?.port || '');
|
|
const remotePort = String(remote?.port || '');
|
|
const relayProto = String(local?.relayProtocol || remote?.relayProtocol || '');
|
|
const turnCandidateAddress = localType === 'relay'
|
|
? `${localIp}${localPort ? `:${localPort}` : ''}`
|
|
: (remoteType === 'relay' ? `${remoteIp}${remotePort ? `:${remotePort}` : ''}` : '');
|
|
const details = `local=${localType || '-'}(${localIp || '-'}${localPort ? `:${localPort}` : ''}); remote=${remoteType || '-'}(${remoteIp || '-'}${remotePort ? `:${remotePort}` : ''})`;
|
|
|
|
if (localType === 'relay' || remoteType === 'relay') {
|
|
const label = turnCandidateAddress
|
|
? t('remaining.call.route_turn_candidate', { address: turnCandidateAddress })
|
|
: (relayProto ? t('remaining.call.via_turn_proto', { protocol: relayProto }) : t('remaining.call.via_turn'));
|
|
return { label, details, localIp, remoteIp, turnCandidateAddress };
|
|
}
|
|
if (localType || remoteType) {
|
|
const sameLan = localIp && remoteIp && (
|
|
(localIp.startsWith('10.') && remoteIp.startsWith('10.'))
|
|
|| (localIp.startsWith('192.168.') && remoteIp.startsWith('192.168.'))
|
|
|| (localIp.startsWith('172.16.') && remoteIp.startsWith('172.16.'))
|
|
);
|
|
return {
|
|
label: sameLan ? t('remaining.call.directly_on_local_network') : t('remaining.call.directly_over_the_internet'),
|
|
details,
|
|
localIp,
|
|
remoteIp,
|
|
turnCandidateAddress: '',
|
|
};
|
|
}
|
|
return { label: '', details, localIp, remoteIp, turnCandidateAddress: '' };
|
|
} catch {
|
|
return { label: '', details: '', localIp: '', remoteIp: '', turnCandidateAddress: '' };
|
|
}
|
|
}
|
|
|
|
function startTransportProbe(call) {
|
|
if (!call?.timers || !call.pc) return;
|
|
if (call.timers.transportProbe) {
|
|
clearInterval(call.timers.transportProbe);
|
|
call.timers.transportProbe = null;
|
|
}
|
|
|
|
const refresh = async () => {
|
|
if (!calls.has(call.callId) || call.phase === 'ended') return;
|
|
if (!call.pc || call.pc.connectionState !== 'connected') return;
|
|
const route = await detectConnectionRoute(call);
|
|
if (!route.label || route.label === call.connectionRouteLabel) return;
|
|
call.connectionRouteLabel = route.label;
|
|
call.connectionRouteDetails = route.details || '';
|
|
setActiveStatus(call);
|
|
await emitDebug(call, 'info', 'peer_connection_route', route.details || route.label);
|
|
};
|
|
|
|
void refresh();
|
|
call.timers.transportProbe = window.setInterval(() => {
|
|
void refresh();
|
|
}, 4000);
|
|
}
|
|
|
|
function startReconnectFlow(call, reason = 'disconnected') {
|
|
if (!call || call.phase === 'ended') return;
|
|
if (!call.connectedAtMs) return;
|
|
if (!call.pc) return;
|
|
if (call.reconnectInProgress) return;
|
|
|
|
call.reconnectInProgress = true;
|
|
call.reconnectAttempts = 0;
|
|
recordCallTimeline(call, 'reconnect_start', `reason=${reason}`);
|
|
setStatus(call, t('remaining.call.connection_lost_reconnecting'), 'reconnecting');
|
|
void emitDebug(call, 'warn', 'peer_connection_reconnect_start', `reason=${reason}`);
|
|
|
|
const maxAttempts = 6;
|
|
const attemptDelayMs = 2500;
|
|
const totalDeadlineMs = 17000;
|
|
|
|
call.timers.reconnectDeadline = setTimeout(() => {
|
|
if (!calls.has(call.callId) || call.phase === 'ended') return;
|
|
if (call.pc?.connectionState === 'connected') return;
|
|
stopReconnectFlow(call);
|
|
void finalizeCall(call, { localReasonCode: 'error', debugReason: 'reconnect_timeout' });
|
|
}, totalDeadlineMs);
|
|
|
|
const runAttempt = async () => {
|
|
if (!calls.has(call.callId) || call.phase === 'ended') return;
|
|
if (!call.pc || call.pc.connectionState === 'connected') {
|
|
stopReconnectFlow(call);
|
|
return;
|
|
}
|
|
|
|
call.reconnectAttempts += 1;
|
|
recordCallTimeline(call, 'reconnect_attempt', `attempt=${call.reconnectAttempts}`);
|
|
try {
|
|
const offer = await call.pc.createOffer({ iceRestart: true });
|
|
await call.pc.setLocalDescription(offer);
|
|
await sendSignal(call, TYPES.OFFER, JSON.stringify(offer));
|
|
await emitDebug(call, 'info', 'peer_connection_reconnect_offer_sent', `attempt=${call.reconnectAttempts}`);
|
|
} catch (error) {
|
|
await emitDebug(call, 'warn', 'peer_connection_reconnect_offer_failed', `attempt=${call.reconnectAttempts}; error=${toErrorText(error)}`);
|
|
}
|
|
|
|
if (call.pc?.connectionState === 'connected') {
|
|
stopReconnectFlow(call);
|
|
return;
|
|
}
|
|
if (call.reconnectAttempts >= maxAttempts) {
|
|
stopReconnectFlow(call);
|
|
await finalizeCall(call, { localReasonCode: 'error', debugReason: 'reconnect_attempts_exhausted' });
|
|
return;
|
|
}
|
|
call.timers.reconnectStep = setTimeout(() => {
|
|
void runAttempt();
|
|
}, attemptDelayMs);
|
|
};
|
|
|
|
void runAttempt();
|
|
}
|
|
|
|
async function finalizeCall(call, {
|
|
localReasonCode = 'error',
|
|
debugReason = '',
|
|
notifyRemoteHangup = false,
|
|
suppressRemoteSignal = false,
|
|
suppressReports = false,
|
|
suppressSummary = false,
|
|
} = {}) {
|
|
if (!call) return;
|
|
recordCallTimeline(
|
|
call,
|
|
'finalize_begin',
|
|
`reason=${localReasonCode || ''}; debug=${debugReason || ''}; phase=${call.phase || ''}`,
|
|
String(localReasonCode || '') === 'completed' ? 'info' : 'warn',
|
|
);
|
|
const diagnosticsBeforeClose = getCallDiagnosticsContext(call);
|
|
cleanupTimers(call);
|
|
stopReconnectFlow(call);
|
|
stopTone();
|
|
if (String(debugReason || '') === 'remote_hangup' && call.direction === 'in') {
|
|
dismissCallUiLocally(call);
|
|
}
|
|
|
|
const shouldNotifyRemoteFailure =
|
|
!suppressRemoteSignal
|
|
&& !notifyRemoteHangup
|
|
&& Boolean(call.remoteSessionId)
|
|
&& String(localReasonCode || '') !== 'completed'
|
|
&& String(debugReason || '') !== 'remote_hangup';
|
|
const shouldBroadcastPreAcceptHangup =
|
|
!suppressRemoteSignal
|
|
&& notifyRemoteHangup
|
|
&& !call.remoteSessionId
|
|
&& call.direction === 'out'
|
|
&& !call.connectedAtMs;
|
|
|
|
if ((notifyRemoteHangup || shouldNotifyRemoteFailure) && call.remoteSessionId) {
|
|
try {
|
|
const dataValue = notifyRemoteHangup
|
|
? ''
|
|
: `setup_failed:${String(localReasonCode || 'error')}:${String(debugReason || '').slice(0, 80)}`;
|
|
await sendSignal(call, TYPES.HANGUP, dataValue);
|
|
} catch {}
|
|
}
|
|
if (shouldBroadcastPreAcceptHangup) {
|
|
try {
|
|
await broadcastSignal(call, TYPES.HANGUP, 'caller_cancelled_before_accept');
|
|
} catch {}
|
|
}
|
|
|
|
await closeMedia(call);
|
|
if (String(localReasonCode || '') === 'completed') {
|
|
await emitDebug(call, 'info', 'debug_connection_success', debugReason || 'completed');
|
|
}
|
|
if (debugReason) {
|
|
await emitDebug(call, 'info', 'call_finalize', `${localReasonCode}:${debugReason}`);
|
|
}
|
|
|
|
const reasonText = debugReason || localReasonCode;
|
|
if (!suppressReports && String(localReasonCode || '') !== 'completed') {
|
|
const failureStage = call.phase || '';
|
|
const failureContext = {
|
|
failureStage,
|
|
connectedBeforeFailure: Boolean(call.connectedAtMs),
|
|
...diagnosticsBeforeClose,
|
|
};
|
|
if (call.direction === 'out') {
|
|
await sendCallDeliveryReport(call, 'outgoing_failed', `outgoing_${localReasonCode}`, reasonText, failureContext);
|
|
} else if (call.direction === 'in') {
|
|
await sendCallDeliveryReport(call, 'incoming_failed', `incoming_${localReasonCode}`, reasonText, failureContext);
|
|
}
|
|
if (String(localReasonCode || '') === 'busy') {
|
|
await sendCallDeliveryReport(call, 'call_busy', 'call_busy', reasonText, failureContext);
|
|
} else if (String(localReasonCode || '') === 'declined') {
|
|
await sendCallDeliveryReport(call, 'call_declined', 'call_declined', reasonText, failureContext);
|
|
}
|
|
if (String(localReasonCode || '') === 'error') {
|
|
await sendCallDeliveryReport(call, 'unknown_error', 'call_unknown_error', reasonText, failureContext);
|
|
}
|
|
}
|
|
|
|
if (!suppressSummary) {
|
|
await sendOutgoingCallSummaryDm(call, localReasonCode);
|
|
}
|
|
|
|
call.phase = 'ended';
|
|
call.statusText = t('remaining.call.call_ended');
|
|
if (String(localReasonCode || '') === 'busy') {
|
|
call.statusText = t('remaining.call.user_is_busy');
|
|
}
|
|
recordCallTimeline(call, 'finalize_end', `reason=${localReasonCode || ''}; status=${call.statusText || ''}`);
|
|
notifyCallState();
|
|
|
|
const finalHoldMs = String(localReasonCode || '') === 'busy' ? 2600 : 0;
|
|
if (finalHoldMs > 0) {
|
|
window.setTimeout(() => {
|
|
calls.delete(call.callId);
|
|
if (activeCallId === call.callId) {
|
|
activeCallId = '';
|
|
}
|
|
notifyCallState();
|
|
}, finalHoldMs);
|
|
return;
|
|
}
|
|
|
|
calls.delete(call.callId);
|
|
if (activeCallId === call.callId) {
|
|
activeCallId = '';
|
|
}
|
|
notifyCallState();
|
|
}
|
|
|
|
async function emitDebug(call, level, message, details = '') {
|
|
if (!call?.debugRunId || typeof debugReporter !== 'function') return;
|
|
try {
|
|
await debugReporter({
|
|
runId: call.debugRunId,
|
|
level,
|
|
message,
|
|
details,
|
|
});
|
|
} catch {}
|
|
}
|
|
|
|
async function sendSignal(call, type, data = '') {
|
|
if (!call.remoteSessionId) return;
|
|
const signalName = getSignalTypeName(type);
|
|
const signalType = getCallSignalType(type);
|
|
const login = String(state?.session?.login || '').trim();
|
|
const storagePwd = String(state?.session?.storagePwdInMemory || '').trim();
|
|
if (!login || !storagePwd || !signalType) {
|
|
throw new Error('Call SendSignal: missing login/storagePwd/signalType');
|
|
}
|
|
try {
|
|
await authService.sendSignal({
|
|
toLogin: call.peerLogin,
|
|
targetMode: SIGNAL_TARGET_SINGLE,
|
|
targetSessionId: call.remoteSessionId,
|
|
signalType,
|
|
signalRequestId: call.callId,
|
|
data: encodeCallSignalData(call.callId, type, data),
|
|
storagePwd,
|
|
includeClientSignature: true,
|
|
});
|
|
recordCallTimeline(call, `signal_out_${signalName}`, `toSession=${call.remoteSessionId}; len=${String(data || '').length}`);
|
|
await emitDebug(call, 'info', `signal_sent_${type}`, `len=${String(data || '').length}`);
|
|
} catch (error) {
|
|
if (String(error?.code || '').toUpperCase() === 'SESSION_NOT_FOUND') {
|
|
recordCallTimeline(
|
|
call,
|
|
`signal_out_${signalName}_session_not_found`,
|
|
`toSession=${call.remoteSessionId}; op=${String(error?.op || '')}; status=${String(error?.status || '')}`,
|
|
'warn',
|
|
);
|
|
}
|
|
recordCallTimeline(call, `signal_out_${signalName}_failed`, `toSession=${call.remoteSessionId}; error=${toErrorText(error)}`, 'warn');
|
|
await emitDebug(call, 'error', `signal_send_failed_${type}`, toErrorText(error));
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function broadcastSignal(call, type, data = '') {
|
|
const signalName = getSignalTypeName(type);
|
|
const signalType = getCallSignalType(type);
|
|
const login = String(state?.session?.login || '').trim();
|
|
const storagePwd = String(state?.session?.storagePwdInMemory || '').trim();
|
|
if (!call?.peerLogin || !login || !storagePwd || !signalType) {
|
|
throw new Error('Call SendSignal broadcast: missing peer/login/storagePwd/signalType');
|
|
}
|
|
try {
|
|
const response = await authService.sendSignal({
|
|
toLogin: call.peerLogin,
|
|
targetMode: SIGNAL_TARGET_ALL,
|
|
signalType,
|
|
signalRequestId: call.callId,
|
|
data: encodeCallSignalData(call.callId, type, data),
|
|
storagePwd,
|
|
includeClientSignature: true,
|
|
});
|
|
recordCallTimeline(
|
|
call,
|
|
`signal_broadcast_${signalName}`,
|
|
`ws=${Number(response?.deliveredWsSessions || response?.deliveredCount || 0)}; push=${Number(response?.deliveredWebPushSessions || response?.deliveredFcmSessions || 0)}`,
|
|
);
|
|
return response || {};
|
|
} catch (error) {
|
|
recordCallTimeline(call, `signal_broadcast_${signalName}_failed`, toErrorText(error), 'warn');
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function notifyPeerSessionsAboutConnectStart(call) {
|
|
const winnerSessionId = String(call?.remoteSessionId || '').trim();
|
|
if (!call || !winnerSessionId) return;
|
|
const data = buildConnectStartData(winnerSessionId);
|
|
try {
|
|
await broadcastSignal(call, TYPES.CONNECT_START, data);
|
|
recordCallTimeline(call, 'connect_start_broadcast_sent', `winnerSession=${winnerSessionId}`);
|
|
await emitDebug(call, 'info', 'connect_start_broadcast_sent', `winnerSession=${winnerSessionId}`);
|
|
} catch (error) {
|
|
recordCallTimeline(call, 'connect_start_broadcast_failed', `winnerSession=${winnerSessionId}; error=${toErrorText(error)}`, 'warn');
|
|
await emitDebug(call, 'warn', 'connect_start_broadcast_failed', toErrorText(error));
|
|
}
|
|
}
|
|
|
|
function ensureReservedVideoTransceiver(call) {
|
|
const pc = call?.pc || null;
|
|
if (!pc) return null;
|
|
if (call.videoTransceiver) return call.videoTransceiver;
|
|
const transceivers = pc.getTransceivers?.() || [];
|
|
const existing = transceivers.find((tr) => tr?.mid !== null && tr?.mid !== undefined && (tr?.receiver?.track?.kind === 'video' || tr?.sender?.track?.kind === 'video'))
|
|
|| transceivers.find((tr) => tr?.receiver?.track?.kind === 'video' || tr?.sender?.track?.kind === 'video')
|
|
|| null;
|
|
if (existing) {
|
|
call.videoTransceiver = existing;
|
|
call.videoSender = existing?.sender || call.videoSender || null;
|
|
return existing;
|
|
}
|
|
const created = pc.addTransceiver('video', { direction: 'sendrecv' });
|
|
call.videoTransceiver = created;
|
|
call.videoSender = created?.sender || null;
|
|
return created;
|
|
}
|
|
|
|
function getNegotiatedVideoDirection(transceiver) {
|
|
return String(transceiver?.currentDirection || '').trim().toLowerCase();
|
|
}
|
|
|
|
function canLocalSideSendVideoWithCurrentNegotiation(transceiver) {
|
|
const negotiated = getNegotiatedVideoDirection(transceiver);
|
|
return negotiated === 'sendrecv' || negotiated === 'sendonly';
|
|
}
|
|
|
|
function ensureRemoteTrackObservers(call, track) {
|
|
if (!call || !track || typeof track !== 'object') return;
|
|
if (!call.remoteTrackObserverIds) {
|
|
call.remoteTrackObserverIds = new Set();
|
|
}
|
|
if (call.remoteTrackObserverIds.has(track.id)) return;
|
|
call.remoteTrackObserverIds.add(track.id);
|
|
track.onended = () => {
|
|
if (track.kind === 'video' && call.remoteMediaStream) {
|
|
try { call.remoteMediaStream.removeTrack(track); } catch {}
|
|
}
|
|
notifyCallState();
|
|
};
|
|
track.onmute = () => notifyCallState();
|
|
track.onunmute = () => notifyCallState();
|
|
}
|
|
|
|
function ensureRemoteMediaStream(call) {
|
|
if (call?.remoteMediaStream) return call.remoteMediaStream;
|
|
const stream = new MediaStream();
|
|
if (call) {
|
|
call.remoteMediaStream = stream;
|
|
}
|
|
return stream;
|
|
}
|
|
|
|
function syncRemoteReceiverVideoTracks(call) {
|
|
const pc = call?.pc || null;
|
|
if (!pc) return false;
|
|
const remoteStream = ensureRemoteMediaStream(call);
|
|
let changed = false;
|
|
const receivers = pc.getReceivers?.() || [];
|
|
receivers.forEach((receiver) => {
|
|
const track = receiver?.track || null;
|
|
if (!track || track.kind !== 'video' || track.readyState === 'ended') return;
|
|
const hasTrack = remoteStream.getVideoTracks().some((existing) => existing.id === track.id);
|
|
if (!hasTrack) {
|
|
try {
|
|
remoteStream.addTrack(track);
|
|
changed = true;
|
|
} catch {}
|
|
}
|
|
ensureRemoteTrackObservers(call, track);
|
|
});
|
|
if (call.remoteAudio) {
|
|
call.remoteAudio.srcObject = remoteStream;
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
async function ensurePeerConnection(call) {
|
|
if (call.pc) return call.pc;
|
|
|
|
const iceServers = await resolveIceServers(call);
|
|
const pc = new RTCPeerConnection({
|
|
iceServers,
|
|
});
|
|
|
|
if (call.debugMode && call.debugRole === 'initiator') {
|
|
const dc = pc.createDataChannel('debug-ping');
|
|
dc.onopen = () => {
|
|
try { dc.send('ping'); } catch {}
|
|
void emitDebug(call, 'info', 'debug_datachannel_open', 'sent ping');
|
|
};
|
|
dc.onmessage = (evt) => {
|
|
void emitDebug(call, 'info', 'debug_datachannel_message', String(evt?.data || ''));
|
|
};
|
|
}
|
|
|
|
pc.ondatachannel = (evt) => {
|
|
const ch = evt?.channel;
|
|
if (!ch) return;
|
|
ch.onmessage = (msg) => {
|
|
const incoming = String(msg?.data || '');
|
|
void emitDebug(call, 'info', 'debug_datachannel_message_in', incoming);
|
|
if (incoming === 'ping') {
|
|
try { ch.send('pong'); } catch {}
|
|
}
|
|
};
|
|
};
|
|
|
|
pc.onicecandidate = async (event) => {
|
|
if (!event.candidate || !call.remoteSessionId) return;
|
|
call.localIceSentCount = Number(call.localIceSentCount || 0) + 1;
|
|
if (call.localIceSentCount <= 3) {
|
|
recordCallTimeline(
|
|
call,
|
|
'ice_local_candidate',
|
|
`count=${call.localIceSentCount}; type=${event.candidate?.type || ''}; protocol=${event.candidate?.protocol || ''}`,
|
|
);
|
|
}
|
|
try {
|
|
await sendSignal(call, TYPES.ICE, JSON.stringify(event.candidate));
|
|
} catch {}
|
|
};
|
|
|
|
pc.onconnectionstatechange = () => {
|
|
const state = pc.connectionState;
|
|
recordCallTimeline(
|
|
call,
|
|
'pc_connection_state',
|
|
`state=${state || ''}; ice=${pc.iceConnectionState || ''}; signal=${pc.signalingState || ''}`,
|
|
state === 'failed' ? 'warn' : 'info',
|
|
);
|
|
if (state === 'connected') {
|
|
stopReconnectFlow(call);
|
|
if (call.timers?.incomingConnect20s) {
|
|
clearTimeout(call.timers.incomingConnect20s);
|
|
call.timers.incomingConnect20s = null;
|
|
}
|
|
if (!call.connectedAtMs) {
|
|
call.connectedAtMs = nowMs();
|
|
}
|
|
refreshVideoSlotReady(call);
|
|
setActiveStatus(call);
|
|
startTransportProbe(call);
|
|
void emitDebug(call, 'info', 'peer_connection_connected', `callId=${call.callId}`);
|
|
if (call.direction === 'out' && !call.connectionSuccessReported) {
|
|
call.connectionSuccessReported = true;
|
|
void (async () => {
|
|
const route = await detectConnectionRoute(call);
|
|
const candidateAnalytics = await collectIceCandidateAnalytics(call);
|
|
if (route?.label) {
|
|
call.connectionRouteLabel = route.label;
|
|
}
|
|
call.connectionRouteDetails = route?.details || '';
|
|
await sendCallDeliveryReport(
|
|
call,
|
|
'call_connected',
|
|
'call_connected_success',
|
|
`connected:${route?.label || 'unknown_route'}`,
|
|
{
|
|
reportBy: 'initiator',
|
|
routeLabel: route?.label || '',
|
|
routeDetails: route?.details || '',
|
|
localIp: route?.localIp || '',
|
|
remoteIp: route?.remoteIp || '',
|
|
turnCandidateAddress: route?.turnCandidateAddress || '',
|
|
...candidateAnalytics,
|
|
},
|
|
);
|
|
})();
|
|
}
|
|
return;
|
|
}
|
|
if (state === 'failed') {
|
|
const failedDetails = `failed;ice=${pc.iceConnectionState || ''};gather=${pc.iceGatheringState || ''};signal=${pc.signalingState || ''}`;
|
|
if (call.connectedAtMs) {
|
|
startReconnectFlow(call, 'failed');
|
|
return;
|
|
}
|
|
void emitDebug(call, 'warn', 'peer_connection_closed', failedDetails);
|
|
void finalizeCall(call, { localReasonCode: 'error', debugReason: failedDetails });
|
|
return;
|
|
}
|
|
if (state === 'disconnected' && call.phase !== 'ended') {
|
|
if (call.connectedAtMs) {
|
|
startReconnectFlow(call, 'disconnected');
|
|
return;
|
|
}
|
|
void emitDebug(call, 'warn', 'peer_connection_closed', `state=${state}`);
|
|
return;
|
|
}
|
|
if (state === 'closed' && call.phase !== 'ended') {
|
|
void emitDebug(call, 'warn', 'peer_connection_closed', `state=${state}`);
|
|
if (call.connectedAtMs) {
|
|
void finalizeCall(call, { localReasonCode: 'error', debugReason: state });
|
|
return;
|
|
}
|
|
void finalizeCall(call, { localReasonCode: 'error', debugReason: state });
|
|
}
|
|
};
|
|
|
|
pc.onsignalingstatechange = () => {
|
|
const state = String(pc.signalingState || '');
|
|
recordCallTimeline(call, 'pc_signaling_state', `state=${state || ''}`);
|
|
if (state === 'stable') {
|
|
if (syncRemoteReceiverVideoTracks(call)) {
|
|
notifyCallState();
|
|
}
|
|
}
|
|
if (state === 'stable' && call.pendingNegotiationReason) {
|
|
void renegotiateCall(call, `signaling_stable:${call.pendingNegotiationReason}`);
|
|
}
|
|
};
|
|
|
|
try {
|
|
const stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false });
|
|
call.localStream = stream;
|
|
call.audioSenders = [];
|
|
call.videoSender = null;
|
|
call.videoTransceiver = null;
|
|
call.connectionRouteLabel = '';
|
|
call.connectionRouteDetails = '';
|
|
recordCallTimeline(call, 'local_media_ready', `tracks=${stream.getTracks().length}`);
|
|
stream.getTracks().forEach((track) => {
|
|
track.enabled = track.kind === 'audio' ? !call.muted : true;
|
|
const sender = pc.addTrack(track, stream);
|
|
if (track.kind === 'audio') {
|
|
call.audioSenders.push(sender);
|
|
}
|
|
});
|
|
if (call.videoTransportMode === VIDEO_TRANSPORT_SLOT) {
|
|
const blackTrack = ensureBlackVideoTrack(call);
|
|
if (blackTrack) {
|
|
const existingVideoTracks = stream.getVideoTracks?.() || [];
|
|
existingVideoTracks.forEach((track) => {
|
|
if (track.id !== blackTrack.id) {
|
|
try { stream.removeTrack(track); } catch {}
|
|
}
|
|
});
|
|
if (!existingVideoTracks.some((track) => track.id === blackTrack.id)) {
|
|
stream.addTrack(blackTrack);
|
|
}
|
|
const sender = pc.addTrack(blackTrack, stream);
|
|
call.videoSender = sender;
|
|
call.videoTransceiver = (pc.getTransceivers?.() || []).find((tr) => tr?.sender === sender) || null;
|
|
bindVideoSenderStream(call, sender);
|
|
await applyVideoSenderEncodingProfile(sender, 'placeholder');
|
|
} else {
|
|
ensureReservedVideoTransceiver(call);
|
|
}
|
|
} else if (call.videoTransportMode === VIDEO_TRANSPORT_RESERVED) {
|
|
ensureReservedVideoTransceiver(call);
|
|
}
|
|
} catch (e) {
|
|
setStatus(call, t('remaining.call.microphone_error_full', { error: e?.message || 'unknown' }), 'failed');
|
|
recordCallTimeline(call, 'local_media_failed', toErrorText(e), 'warn');
|
|
await emitDebug(call, 'warn', 'microphone_access_failed', toErrorText(e));
|
|
throw e;
|
|
}
|
|
|
|
pc.ontrack = (evt) => {
|
|
const trackKind = String(evt?.track?.kind || '');
|
|
recordCallTimeline(call, 'remote_track_received', `kind=${trackKind || '-'}; streams=${evt?.streams?.length || 0}`);
|
|
let remoteStream = call.remoteMediaStream || null;
|
|
if (evt?.streams?.[0]) {
|
|
remoteStream = evt.streams[0];
|
|
} else {
|
|
if (!remoteStream) remoteStream = new MediaStream();
|
|
if (evt?.track && !remoteStream.getTracks().some((track) => track.id === evt.track.id)) {
|
|
remoteStream.addTrack(evt.track);
|
|
}
|
|
}
|
|
call.remoteMediaStream = remoteStream;
|
|
if (trackKind === 'video') {
|
|
call.videoEverActivated = true;
|
|
}
|
|
if (!call.remoteAudio) {
|
|
const audio = new Audio();
|
|
audio.autoplay = true;
|
|
audio.playsInline = true;
|
|
call.remoteAudio = audio;
|
|
}
|
|
if (evt?.track) ensureRemoteTrackObservers(call, evt.track);
|
|
call.remoteAudio.srcObject = remoteStream;
|
|
syncRemoteReceiverVideoTracks(call);
|
|
void call.remoteAudio.play?.().catch?.(() => {});
|
|
notifyCallState();
|
|
};
|
|
|
|
call.pc = pc;
|
|
if (!Array.isArray(call.pendingRemoteIceCandidates)) {
|
|
call.pendingRemoteIceCandidates = [];
|
|
}
|
|
return pc;
|
|
}
|
|
|
|
function queueNegotiationReason(call, reason = '') {
|
|
if (!call) return '';
|
|
const normalized = String(reason || '').trim() || 'pending';
|
|
call.pendingNegotiationReason = normalized;
|
|
return normalized;
|
|
}
|
|
|
|
async function renegotiateCall(call, reason = '') {
|
|
if (!call?.pc || !call.remoteSessionId) return false;
|
|
const queuedReason = queueNegotiationReason(call, reason);
|
|
if (call.negotiationInProgress) {
|
|
recordCallTimeline(call, 'renegotiate_queued_busy', `reason=${queuedReason || '-'}`);
|
|
return false;
|
|
}
|
|
const pc = call.pc;
|
|
if (pc.signalingState !== 'stable') {
|
|
recordCallTimeline(call, 'renegotiate_queued_unstable', `state=${pc.signalingState}; reason=${queuedReason || '-'}`);
|
|
return false;
|
|
}
|
|
const activeReason = String(call.pendingNegotiationReason || queuedReason || 'pending').trim() || 'pending';
|
|
call.pendingNegotiationReason = '';
|
|
call.negotiationInProgress = true;
|
|
try {
|
|
recordCallTimeline(call, 'renegotiate_start', `reason=${activeReason || '-'}`);
|
|
const offer = await pc.createOffer();
|
|
await pc.setLocalDescription(offer);
|
|
await sendSignal(call, TYPES.OFFER, JSON.stringify(offer));
|
|
recordCallTimeline(call, 'renegotiate_offer_sent', `reason=${activeReason || '-'}`);
|
|
return true;
|
|
} catch (error) {
|
|
if (!call.pendingNegotiationReason) {
|
|
call.pendingNegotiationReason = activeReason;
|
|
}
|
|
throw error;
|
|
} finally {
|
|
call.negotiationInProgress = false;
|
|
if (call.pendingNegotiationReason && call.pc?.signalingState === 'stable') {
|
|
queueMicrotask(() => {
|
|
void renegotiateCall(call, `queued:${call.pendingNegotiationReason}`);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
async function onAccept(call) {
|
|
if (!call) return;
|
|
if (call.initialOfferInProgress || call.initialOfferSent) {
|
|
await emitDebug(call, 'warn', 'accept_duplicate_ignored', `phase=${call.phase || ''}`);
|
|
return;
|
|
}
|
|
recordCallTimeline(call, 'offer_start', `remoteSession=${call.remoteSessionId || ''}`);
|
|
call.initialOfferInProgress = true;
|
|
cleanupTimers(call);
|
|
setStatus(call, t('remaining.call.connecting'), 'connecting');
|
|
try {
|
|
await notifyPeerSessionsAboutConnectStart(call);
|
|
const pc = await ensurePeerConnection(call);
|
|
if (call.videoTransportMode === VIDEO_TRANSPORT_SLOT || call.videoTransportMode === VIDEO_TRANSPORT_RESERVED) {
|
|
ensureReservedVideoTransceiver(call);
|
|
}
|
|
if (call.autoEnableCameraOnConnect && call.cameraEnabled) {
|
|
try {
|
|
await applyCameraState(call);
|
|
} catch {}
|
|
}
|
|
const offer = await pc.createOffer();
|
|
await pc.setLocalDescription(offer);
|
|
call.initialOfferSent = true;
|
|
await sendSignal(call, TYPES.OFFER, JSON.stringify(offer));
|
|
await emitDebug(call, 'info', 'offer_sent', 'offer created and sent');
|
|
} finally {
|
|
call.initialOfferInProgress = false;
|
|
}
|
|
}
|
|
|
|
function ensureIncomingNotification(peerLogin, mode = CALL_MODE_AUDIO) {
|
|
if (typeof window === 'undefined') return;
|
|
const text = getIncomingCallStatusText(peerLogin, mode);
|
|
try {
|
|
if ('Notification' in window && Notification.permission === 'granted') {
|
|
new Notification(t('remaining.call.shine_incoming_call'), { body: text });
|
|
}
|
|
} catch {}
|
|
try {
|
|
if ('vibrate' in navigator) {
|
|
navigator.vibrate([180, 70, 180, 70, 260]);
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
function isIncomingCallPushFresh(payload) {
|
|
const expiresAtMs = Number(payload?.expiresAtMs || 0);
|
|
if (Number.isFinite(expiresAtMs) && expiresAtMs > 0 && Date.now() > expiresAtMs) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function isCallPushForCurrentSession(payload = {}) {
|
|
const targetSessionId = String(payload?.targetSessionId || '').trim();
|
|
if (!targetSessionId) return true;
|
|
const currentSessionId = String(state?.session?.sessionId || '').trim();
|
|
return Boolean(currentSessionId) && currentSessionId === targetSessionId;
|
|
}
|
|
|
|
async function handleIncomingInvitePayload(payload, { source = 'ws' } = {}) {
|
|
const callId = String(payload?.callId || '').trim();
|
|
const fromLogin = String(payload?.fromLogin || '').trim();
|
|
const fromSessionId = String(payload?.fromSessionId || '').trim();
|
|
const type = Number(payload?.type || TYPES.INVITE);
|
|
const inviteMeta = parseInviteData(payload?.data || '');
|
|
const callMode = inviteMeta.mode;
|
|
if (type === TYPES.CONNECT_START) {
|
|
const call = getCall(callId);
|
|
if (!call || call.direction !== 'in' || call.phase === 'ended') return call;
|
|
const winnerSessionId = parseConnectStartWinnerSessionId(payload?.data || '');
|
|
const currentSessionId = String(state?.session?.sessionId || '').trim();
|
|
recordCallTimeline(call, 'connect_start_broadcast_received', `winnerSession=${winnerSessionId || '-'}; currentSession=${currentSessionId || '-'}`);
|
|
if (winnerSessionId && currentSessionId && winnerSessionId === currentSessionId) {
|
|
await emitDebug(call, 'info', 'connect_start_kept_on_winner_session', winnerSessionId);
|
|
return call;
|
|
}
|
|
dismissCallUiLocally(call);
|
|
await finalizeCall(call, {
|
|
localReasonCode: 'completed',
|
|
debugReason: 'answered_elsewhere_session_selected',
|
|
suppressRemoteSignal: true,
|
|
suppressReports: true,
|
|
suppressSummary: true,
|
|
});
|
|
return call;
|
|
}
|
|
if (!callId || !fromLogin || !fromSessionId) return null;
|
|
|
|
if (activeCallId && activeCallId !== callId) {
|
|
try {
|
|
await authService.sendSignal({
|
|
toLogin: fromLogin,
|
|
targetMode: SIGNAL_TARGET_SINGLE,
|
|
targetSessionId: fromSessionId,
|
|
signalType: getCallSignalType(TYPES.DECLINE_BUSY),
|
|
signalRequestId: callId,
|
|
data: encodeCallSignalData(callId, TYPES.DECLINE_BUSY, 'busy'),
|
|
storagePwd: state?.session?.storagePwdInMemory || '',
|
|
includeClientSignature: true,
|
|
});
|
|
} catch {}
|
|
return null;
|
|
}
|
|
|
|
let call = getCall(callId);
|
|
if (!call) {
|
|
call = {
|
|
callId,
|
|
peerLogin: fromLogin,
|
|
callMode,
|
|
videoTransportMode: getVideoTransportModeForCallMode(callMode),
|
|
autoEnableCameraOnConnect: isInstantVideoMode(callMode),
|
|
direction: 'in',
|
|
phase: 'incoming',
|
|
statusText: getIncomingCallStatusText(fromLogin, callMode),
|
|
remoteSessionId: fromSessionId,
|
|
timers: {},
|
|
startedAtMs: nowMs(),
|
|
connectedAtMs: 0,
|
|
pc: null,
|
|
localStream: null,
|
|
localVideoTrack: null,
|
|
remoteMediaStream: null,
|
|
audioSenders: [],
|
|
videoSender: null,
|
|
videoTransceiver: null,
|
|
muted: false,
|
|
cameraEnabled: false,
|
|
videoEverActivated: false,
|
|
connectionRouteLabel: '',
|
|
reconnectInProgress: false,
|
|
reconnectAttempts: 0,
|
|
debugMode: false,
|
|
debugRunId: '',
|
|
debugRole: '',
|
|
pendingRemoteIceCandidates: [],
|
|
pendingNegotiationReason: '',
|
|
initialOfferInProgress: false,
|
|
initialOfferSent: false,
|
|
timelineEvents: [],
|
|
timelineSeq: 0,
|
|
timelineBaseMs: nowMs(),
|
|
};
|
|
calls.set(callId, call);
|
|
recordCallTimeline(call, 'incoming_invite_created', `from=${fromLogin}; session=${fromSessionId}; source=${source}`);
|
|
} else if (!call.remoteSessionId && fromSessionId) {
|
|
setRemoteSessionId(call, fromSessionId, 'incoming_invite_existing_call');
|
|
}
|
|
|
|
if (!call.callMode) call.callMode = callMode;
|
|
if (!call.videoTransportMode) call.videoTransportMode = getVideoTransportModeForCallMode(call.callMode);
|
|
if (typeof call.autoEnableCameraOnConnect !== 'boolean') {
|
|
call.autoEnableCameraOnConnect = isInstantVideoMode(call.callMode);
|
|
}
|
|
|
|
activeCallId = callId;
|
|
setStatus(call, getIncomingCallStatusText(fromLogin, call.callMode), 'incoming');
|
|
ensureIncomingNotification(fromLogin, call.callMode);
|
|
|
|
try {
|
|
await sendSignal(call, TYPES.RINGING, `ringing:${source}`);
|
|
} catch {}
|
|
|
|
if (!call.timers.incoming20s) {
|
|
call.timers.incoming20s = setTimeout(async () => {
|
|
if (!calls.has(callId)) return;
|
|
try {
|
|
await sendSignal(call, TYPES.TIMEOUT, 'timeout_20s');
|
|
} catch {}
|
|
await finalizeCall(call, { localReasonCode: 'no_answer', debugReason: 'incoming_timeout_20s' });
|
|
}, 20000);
|
|
}
|
|
return call;
|
|
}
|
|
|
|
export function setCallDebugReporter(fn) {
|
|
debugReporter = typeof fn === 'function' ? fn : null;
|
|
}
|
|
|
|
export function subscribeCallState(listener) {
|
|
if (typeof listener !== 'function') {
|
|
return () => {};
|
|
}
|
|
callStateListeners.add(listener);
|
|
try {
|
|
listener(getCallStateSnapshot());
|
|
} catch {}
|
|
return () => {
|
|
callStateListeners.delete(listener);
|
|
};
|
|
}
|
|
|
|
export function getActiveCallState() {
|
|
return getCallStateSnapshot();
|
|
}
|
|
|
|
async function applyMicState(call) {
|
|
if (!call) return;
|
|
const muted = Boolean(call.muted);
|
|
const audioTracks = call.localStream?.getAudioTracks?.() || [];
|
|
audioTracks.forEach((track) => {
|
|
track.enabled = !muted;
|
|
});
|
|
|
|
const senders = Array.isArray(call.audioSenders) && call.audioSenders.length > 0
|
|
? call.audioSenders
|
|
: (call.pc?.getSenders?.() || []);
|
|
const sourceTrack = audioTracks[0] || null;
|
|
|
|
for (const sender of senders) {
|
|
if (!sender || typeof sender.replaceTrack !== 'function') continue;
|
|
try {
|
|
if (muted) {
|
|
if (sender.track) {
|
|
await sender.replaceTrack(null);
|
|
}
|
|
} else if (sourceTrack) {
|
|
if (sender.track !== sourceTrack) {
|
|
await sender.replaceTrack(sourceTrack);
|
|
}
|
|
sourceTrack.enabled = true;
|
|
}
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
async function ensureCameraTrack(call) {
|
|
const existingTrack = call?.localVideoTrack;
|
|
if (existingTrack && existingTrack.readyState === 'live') {
|
|
existingTrack.enabled = true;
|
|
return existingTrack;
|
|
}
|
|
const videoStream = await navigator.mediaDevices.getUserMedia({ video: CAMERA_CONSTRAINTS, audio: false });
|
|
const videoTrack = videoStream.getVideoTracks?.()[0] || null;
|
|
if (!videoTrack) {
|
|
throw new Error('Не удалось получить видеотрек');
|
|
}
|
|
const streamTracks = videoStream.getTracks?.() || [];
|
|
streamTracks.forEach((track) => {
|
|
if (track !== videoTrack) {
|
|
try { track.stop(); } catch {}
|
|
}
|
|
});
|
|
if (!call.localStream) {
|
|
call.localStream = new MediaStream();
|
|
}
|
|
const currentLocalVideoTracks = call.localStream.getVideoTracks?.() || [];
|
|
currentLocalVideoTracks.forEach((track) => {
|
|
if (track.id !== videoTrack.id) {
|
|
try { call.localStream.removeTrack(track); } catch {}
|
|
try { track.stop(); } catch {}
|
|
}
|
|
});
|
|
call.localStream.addTrack(videoTrack);
|
|
call.localVideoTrack = videoTrack;
|
|
call.videoEverActivated = true;
|
|
return videoTrack;
|
|
}
|
|
|
|
function ensureBlackVideoTrack(call) {
|
|
const existingTrack = call?.placeholderBlackVideoTrack || null;
|
|
if (existingTrack && existingTrack.readyState === 'live') {
|
|
existingTrack.enabled = true;
|
|
return existingTrack;
|
|
}
|
|
const canvas = document.createElement('canvas');
|
|
canvas.width = 160;
|
|
canvas.height = 90;
|
|
const ctx = canvas.getContext('2d');
|
|
if (!ctx || typeof canvas.captureStream !== 'function') {
|
|
return null;
|
|
}
|
|
ctx.fillStyle = '#000000';
|
|
ctx.fillRect(0, 0, canvas.width, canvas.height);
|
|
const stream = canvas.captureStream(1);
|
|
const track = stream.getVideoTracks?.()[0] || null;
|
|
if (!track) return null;
|
|
call.placeholderBlackCanvas = canvas;
|
|
call.placeholderBlackStream = stream;
|
|
call.placeholderBlackVideoTrack = track;
|
|
return track;
|
|
}
|
|
|
|
async function applyVideoSenderEncodingProfile(sender, mode = 'camera') {
|
|
if (!sender || typeof sender.getParameters !== 'function' || typeof sender.setParameters !== 'function') {
|
|
return;
|
|
}
|
|
try {
|
|
const params = sender.getParameters() || {};
|
|
const encodings = Array.isArray(params.encodings) && params.encodings.length > 0
|
|
? [...params.encodings]
|
|
: [{}];
|
|
const nextEncoding = { ...encodings[0] };
|
|
if (mode === 'placeholder') {
|
|
nextEncoding.maxBitrate = 12000;
|
|
nextEncoding.maxFramerate = 1;
|
|
nextEncoding.scaleResolutionDownBy = 1;
|
|
nextEncoding.active = true;
|
|
} else {
|
|
delete nextEncoding.maxBitrate;
|
|
delete nextEncoding.maxFramerate;
|
|
delete nextEncoding.scaleResolutionDownBy;
|
|
nextEncoding.active = true;
|
|
}
|
|
params.encodings = [nextEncoding];
|
|
await sender.setParameters(params);
|
|
} catch {}
|
|
}
|
|
|
|
async function disableCameraTrack(call) {
|
|
const videoTrack = call?.localVideoTrack || null;
|
|
if (videoTrack) {
|
|
try { videoTrack.enabled = false; } catch {}
|
|
try { call.localStream?.removeTrack?.(videoTrack); } catch {}
|
|
try { videoTrack.stop(); } catch {}
|
|
}
|
|
call.localVideoTrack = null;
|
|
}
|
|
|
|
function bindVideoSenderStream(call, sender) {
|
|
if (!call?.localStream || !sender || typeof sender.setStreams !== 'function') return;
|
|
try {
|
|
sender.setStreams(call.localStream);
|
|
} catch {}
|
|
}
|
|
|
|
async function applyCameraState(call) {
|
|
if (!call?.pc) return false;
|
|
const pc = call.pc;
|
|
const hadSlotBefore = call.videoTransportMode === VIDEO_TRANSPORT_SLOT;
|
|
const hadReservedBefore = call.videoTransportMode === VIDEO_TRANSPORT_RESERVED;
|
|
let requireVideoRenegotiation = false;
|
|
let videoTransceiver = call.videoTransceiver || null;
|
|
if (!videoTransceiver) {
|
|
const transceivers = pc.getTransceivers?.() || [];
|
|
videoTransceiver = transceivers.find((tr) => tr?.sender?.track?.kind === 'video' || tr?.receiver?.track?.kind === 'video') || null;
|
|
call.videoTransceiver = videoTransceiver;
|
|
call.videoSender = videoTransceiver?.sender || call.videoSender || null;
|
|
}
|
|
if (call.cameraEnabled) {
|
|
if (hadSlotBefore) {
|
|
const videoTrack = await ensureCameraTrack(call);
|
|
if (!videoTransceiver) {
|
|
videoTransceiver = pc.addTransceiver('video', { direction: 'sendrecv' });
|
|
call.videoTransceiver = videoTransceiver;
|
|
call.videoSender = videoTransceiver?.sender || null;
|
|
}
|
|
try {
|
|
if (videoTransceiver && videoTransceiver.direction !== 'sendrecv') {
|
|
videoTransceiver.direction = 'sendrecv';
|
|
}
|
|
} catch {}
|
|
if (videoTransceiver?.sender) {
|
|
await videoTransceiver.sender.replaceTrack(videoTrack);
|
|
call.videoSender = videoTransceiver.sender;
|
|
bindVideoSenderStream(call, videoTransceiver.sender);
|
|
await applyVideoSenderEncodingProfile(videoTransceiver.sender, 'camera');
|
|
} else {
|
|
const sender = pc.addTrack(videoTrack, call.localStream);
|
|
call.videoSender = sender;
|
|
bindVideoSenderStream(call, sender);
|
|
await applyVideoSenderEncodingProfile(sender, 'camera');
|
|
}
|
|
videoTrack.enabled = true;
|
|
} else if (hadReservedBefore) {
|
|
const videoTrack = await ensureCameraTrack(call);
|
|
if (!videoTransceiver) {
|
|
videoTransceiver = ensureReservedVideoTransceiver(call);
|
|
call.videoTransceiver = videoTransceiver;
|
|
call.videoSender = videoTransceiver?.sender || call.videoSender || null;
|
|
requireVideoRenegotiation = true;
|
|
}
|
|
try {
|
|
if (videoTransceiver && videoTransceiver.direction !== 'sendrecv') {
|
|
videoTransceiver.direction = 'sendrecv';
|
|
}
|
|
} catch {}
|
|
if (videoTransceiver?.sender) {
|
|
await videoTransceiver.sender.replaceTrack(videoTrack);
|
|
call.videoSender = videoTransceiver.sender;
|
|
bindVideoSenderStream(call, videoTransceiver.sender);
|
|
await applyVideoSenderEncodingProfile(videoTransceiver.sender, 'camera');
|
|
} else {
|
|
const sender = pc.addTrack(videoTrack, call.localStream);
|
|
call.videoSender = sender;
|
|
bindVideoSenderStream(call, sender);
|
|
await applyVideoSenderEncodingProfile(sender, 'camera');
|
|
}
|
|
call.videoTransportMode = VIDEO_TRANSPORT_SLOT;
|
|
videoTrack.enabled = true;
|
|
if (!canLocalSideSendVideoWithCurrentNegotiation(videoTransceiver)) {
|
|
requireVideoRenegotiation = true;
|
|
}
|
|
} else {
|
|
call.videoTransportMode = VIDEO_TRANSPORT_SLOT;
|
|
const videoTrack = await ensureCameraTrack(call);
|
|
await ensureVideoSenderSlot(call, { sourceTrack: videoTrack, profile: 'camera' });
|
|
videoTransceiver = call.videoTransceiver || videoTransceiver;
|
|
try {
|
|
if (videoTransceiver && videoTransceiver.direction !== 'sendrecv') {
|
|
videoTransceiver.direction = 'sendrecv';
|
|
}
|
|
} catch {}
|
|
videoTrack.enabled = true;
|
|
}
|
|
} else {
|
|
const blackTrack = ensureBlackVideoTrack(call);
|
|
if (hadSlotBefore) {
|
|
if (call.localStream && blackTrack) {
|
|
const existingVideoTracks = call.localStream.getVideoTracks?.() || [];
|
|
existingVideoTracks.forEach((track) => {
|
|
if (track.id !== blackTrack.id) {
|
|
try { call.localStream.removeTrack(track); } catch {}
|
|
}
|
|
});
|
|
if (!existingVideoTracks.some((track) => track.id === blackTrack.id)) {
|
|
call.localStream.addTrack(blackTrack);
|
|
}
|
|
}
|
|
try {
|
|
if (videoTransceiver && videoTransceiver.direction !== 'sendrecv') {
|
|
videoTransceiver.direction = 'sendrecv';
|
|
}
|
|
} catch {}
|
|
if (videoTransceiver?.sender) {
|
|
try { await videoTransceiver.sender.replaceTrack(blackTrack || null); } catch {}
|
|
call.videoSender = videoTransceiver.sender;
|
|
bindVideoSenderStream(call, videoTransceiver.sender);
|
|
await applyVideoSenderEncodingProfile(videoTransceiver.sender, 'placeholder');
|
|
}
|
|
} else {
|
|
if (call.localStream && blackTrack) {
|
|
syncLocalStreamVideoTrack(call, blackTrack, { stopRemoved: false });
|
|
}
|
|
try {
|
|
if (videoTransceiver && videoTransceiver.direction !== 'sendrecv') {
|
|
videoTransceiver.direction = 'sendrecv';
|
|
}
|
|
} catch {}
|
|
if (hadReservedBefore && videoTransceiver?.sender) {
|
|
try { await videoTransceiver.sender.replaceTrack(null); } catch {}
|
|
call.videoSender = videoTransceiver.sender;
|
|
} else if (call.videoTransportMode === VIDEO_TRANSPORT_SLOT && blackTrack) {
|
|
await ensureVideoSenderSlot(call, { sourceTrack: blackTrack, profile: 'placeholder' });
|
|
}
|
|
}
|
|
await disableCameraTrack(call);
|
|
}
|
|
notifyCallState();
|
|
if (requireVideoRenegotiation) {
|
|
await renegotiateCall(call, 'enable_video_reserved_sender');
|
|
return true;
|
|
}
|
|
if (!hadSlotBefore && !hadReservedBefore && call.videoTransportMode === VIDEO_TRANSPORT_SLOT && !refreshVideoSlotReady(call)) {
|
|
await renegotiateCall(call, 'upgrade_to_video_slot');
|
|
}
|
|
return true;
|
|
}
|
|
|
|
export async function setMicMuted(muted) {
|
|
const call = getActiveCall();
|
|
if (!call) return;
|
|
call.muted = Boolean(muted);
|
|
await applyMicState(call);
|
|
notifyCallState();
|
|
}
|
|
|
|
export async function toggleMicMuted() {
|
|
const call = getActiveCall();
|
|
if (!call) return;
|
|
await setMicMuted(!call.muted);
|
|
}
|
|
|
|
export async function setCameraEnabled(enabled) {
|
|
const call = getActiveCall();
|
|
if (!call || !call.pc) return false;
|
|
const nextEnabled = Boolean(enabled);
|
|
if (Boolean(call.cameraEnabled) === nextEnabled) return true;
|
|
call.cameraEnabled = nextEnabled;
|
|
try {
|
|
await applyCameraState(call);
|
|
notifyCallState();
|
|
return true;
|
|
} catch (error) {
|
|
call.cameraEnabled = !nextEnabled;
|
|
notifyCallState();
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
function syncLocalStreamVideoTrack(call, preferredTrack, { stopRemoved = false } = {}) {
|
|
if (!call?.localStream || !preferredTrack) return;
|
|
const currentVideoTracks = call.localStream.getVideoTracks?.() || [];
|
|
currentVideoTracks.forEach((track) => {
|
|
if (track.id !== preferredTrack.id) {
|
|
try { call.localStream.removeTrack(track); } catch {}
|
|
if (stopRemoved) {
|
|
try { track.stop(); } catch {}
|
|
}
|
|
}
|
|
});
|
|
if (!currentVideoTracks.some((track) => track.id === preferredTrack.id)) {
|
|
call.localStream.addTrack(preferredTrack);
|
|
}
|
|
}
|
|
|
|
async function ensureVideoSenderSlot(call, { sourceTrack = null, profile = 'placeholder' } = {}) {
|
|
const pc = call?.pc || null;
|
|
const stream = call?.localStream || null;
|
|
if (!pc || !stream) return null;
|
|
|
|
const track = sourceTrack || ensureBlackVideoTrack(call);
|
|
if (!track) return null;
|
|
syncLocalStreamVideoTrack(call, track, { stopRemoved: false });
|
|
|
|
let transceiver = call.videoTransceiver || null;
|
|
if (!transceiver) {
|
|
const transceivers = pc.getTransceivers?.() || [];
|
|
transceiver = transceivers.find((tr) => tr?.sender?.track?.kind === 'video' || tr?.receiver?.track?.kind === 'video') || null;
|
|
call.videoTransceiver = transceiver;
|
|
call.videoSender = transceiver?.sender || call.videoSender || null;
|
|
}
|
|
|
|
if (transceiver?.sender) {
|
|
try { await transceiver.sender.replaceTrack(track); } catch {}
|
|
call.videoSender = transceiver.sender;
|
|
bindVideoSenderStream(call, transceiver.sender);
|
|
await applyVideoSenderEncodingProfile(transceiver.sender, profile);
|
|
return transceiver.sender;
|
|
}
|
|
|
|
const sender = pc.addTrack(track, stream);
|
|
call.videoSender = sender;
|
|
call.videoTransceiver = (pc.getTransceivers?.() || []).find((tr) => tr?.sender === sender) || null;
|
|
bindVideoSenderStream(call, sender);
|
|
await applyVideoSenderEncodingProfile(sender, profile);
|
|
return sender;
|
|
}
|
|
|
|
export async function toggleCameraEnabled() {
|
|
const call = getActiveCall();
|
|
if (!call) return false;
|
|
return setCameraEnabled(!call.cameraEnabled);
|
|
}
|
|
|
|
export async function toggleSpeakerMode() {
|
|
const call = getActiveCall();
|
|
if (!call || !call.remoteAudio || !canRouteAudioOutputInBrowser()) return false;
|
|
const audio = call.remoteAudio;
|
|
if (Boolean(call.speakerEnabled)) {
|
|
try {
|
|
await audio.setSinkId('');
|
|
call.speakerEnabled = false;
|
|
notifyCallState();
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
try {
|
|
const options = call.speakerSinkId ? { deviceId: call.speakerSinkId } : undefined;
|
|
const selected = await navigator.mediaDevices.selectAudioOutput(options);
|
|
const deviceId = String(selected?.deviceId || '').trim();
|
|
if (!deviceId) return false;
|
|
await audio.setSinkId(deviceId);
|
|
call.speakerSinkId = deviceId;
|
|
call.speakerEnabled = true;
|
|
notifyCallState();
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
export async function startDebugConnectionAsResponder({ runId, callId, peerLogin, peerSessionId }) {
|
|
const cleanCallId = String(callId || '').trim();
|
|
const cleanPeerLogin = String(peerLogin || '').trim();
|
|
const cleanPeerSessionId = String(peerSessionId || '').trim();
|
|
if (!cleanCallId || !cleanPeerLogin || !cleanPeerSessionId) return;
|
|
|
|
let call = getCall(cleanCallId);
|
|
if (!call) {
|
|
call = {
|
|
callId: cleanCallId,
|
|
peerLogin: cleanPeerLogin,
|
|
callMode: CALL_MODE_AUDIO,
|
|
videoTransportMode: VIDEO_TRANSPORT_NONE,
|
|
autoEnableCameraOnConnect: false,
|
|
direction: 'in',
|
|
phase: 'incoming',
|
|
statusText: 'Debug: responder ждёт offer',
|
|
remoteSessionId: cleanPeerSessionId,
|
|
timers: {},
|
|
startedAtMs: nowMs(),
|
|
connectedAtMs: 0,
|
|
pc: null,
|
|
localStream: null,
|
|
localVideoTrack: null,
|
|
remoteMediaStream: null,
|
|
audioSenders: [],
|
|
videoSender: null,
|
|
videoTransceiver: null,
|
|
muted: false,
|
|
cameraEnabled: false,
|
|
videoEverActivated: false,
|
|
connectionRouteLabel: '',
|
|
debugMode: true,
|
|
debugRunId: String(runId || '').trim(),
|
|
debugRole: 'responder',
|
|
pendingRemoteIceCandidates: [],
|
|
pendingNegotiationReason: '',
|
|
initialOfferInProgress: false,
|
|
initialOfferSent: false,
|
|
};
|
|
calls.set(cleanCallId, call);
|
|
}
|
|
if (!Array.isArray(call.pendingRemoteIceCandidates)) call.pendingRemoteIceCandidates = [];
|
|
if (typeof call.initialOfferInProgress !== 'boolean') call.initialOfferInProgress = false;
|
|
if (typeof call.initialOfferSent !== 'boolean') call.initialOfferSent = false;
|
|
|
|
activeCallId = cleanCallId;
|
|
await emitDebug(call, 'info', 'debug_prepare_responder', `peerSessionId=${cleanPeerSessionId}`);
|
|
setStatus(call, 'Debug: responder готов, ждём offer', 'incoming');
|
|
}
|
|
|
|
export async function startDebugConnectionAsInitiator({ runId, callId, peerLogin, peerSessionId }) {
|
|
const cleanCallId = String(callId || '').trim();
|
|
const cleanPeerLogin = String(peerLogin || '').trim();
|
|
const cleanPeerSessionId = String(peerSessionId || '').trim();
|
|
if (!cleanCallId || !cleanPeerLogin || !cleanPeerSessionId) return;
|
|
|
|
const call = {
|
|
callId: cleanCallId,
|
|
peerLogin: cleanPeerLogin,
|
|
callMode: CALL_MODE_AUDIO,
|
|
videoTransportMode: VIDEO_TRANSPORT_NONE,
|
|
autoEnableCameraOnConnect: false,
|
|
direction: 'out',
|
|
phase: 'connecting',
|
|
statusText: 'Debug: старт соединения',
|
|
remoteSessionId: cleanPeerSessionId,
|
|
timers: {},
|
|
startedAtMs: nowMs(),
|
|
connectedAtMs: 0,
|
|
pc: null,
|
|
localStream: null,
|
|
localVideoTrack: null,
|
|
remoteMediaStream: null,
|
|
audioSenders: [],
|
|
videoSender: null,
|
|
videoTransceiver: null,
|
|
muted: false,
|
|
cameraEnabled: false,
|
|
videoEverActivated: false,
|
|
connectionRouteLabel: '',
|
|
debugMode: true,
|
|
debugRunId: String(runId || '').trim(),
|
|
debugRole: 'initiator',
|
|
pendingRemoteIceCandidates: [],
|
|
pendingNegotiationReason: '',
|
|
initialOfferInProgress: false,
|
|
initialOfferSent: false,
|
|
timelineEvents: [],
|
|
timelineSeq: 0,
|
|
timelineBaseMs: nowMs(),
|
|
};
|
|
|
|
calls.set(cleanCallId, call);
|
|
activeCallId = cleanCallId;
|
|
recordCallTimeline(call, 'debug_initiator_created', `peer=${cleanPeerLogin}; session=${cleanPeerSessionId}`);
|
|
notifyCallState();
|
|
await emitDebug(call, 'info', 'debug_start_initiator', `peerSessionId=${cleanPeerSessionId}`);
|
|
try {
|
|
await onAccept(call);
|
|
} catch (error) {
|
|
await emitDebug(call, 'error', 'debug_initiator_start_failed', toErrorText(error));
|
|
await finalizeCall(call, { localReasonCode: 'error', debugReason: toErrorText(error) });
|
|
}
|
|
}
|
|
|
|
export async function startOutgoingCall(peerLogin, options = {}) {
|
|
const cleanPeer = String(peerLogin || '').trim();
|
|
if (!cleanPeer) return;
|
|
|
|
const active = getActiveCall();
|
|
if (active) {
|
|
throw new Error(t('remaining.call.active_call_already', { peer: active.peerLogin || t('remaining.call.another_user') }));
|
|
}
|
|
|
|
const callId = makeCallId();
|
|
const callMode = normalizeCallMode(options?.mode || CALL_MODE_AUDIO);
|
|
const preflightTimeoutMs = resolveCallPreflightTimeoutMs();
|
|
const preflightOk = await ensureSessionForCall({ timeoutMs: preflightTimeoutMs, force: false });
|
|
if (!preflightOk) {
|
|
throw new Error(t('remaining.call.server_temporarily_unavailable'));
|
|
}
|
|
|
|
const call = {
|
|
callId,
|
|
peerLogin: cleanPeer,
|
|
callMode,
|
|
videoTransportMode: getVideoTransportModeForCallMode(callMode),
|
|
autoEnableCameraOnConnect: isInstantVideoMode(callMode),
|
|
direction: 'out',
|
|
phase: 'searching',
|
|
statusText: t('remaining.call.finding_user'),
|
|
remoteSessionId: '',
|
|
timers: {},
|
|
startedAtMs: nowMs(),
|
|
connectedAtMs: 0,
|
|
pc: null,
|
|
localStream: null,
|
|
localVideoTrack: null,
|
|
remoteMediaStream: null,
|
|
audioSenders: [],
|
|
videoSender: null,
|
|
videoTransceiver: null,
|
|
muted: false,
|
|
cameraEnabled: isInstantVideoMode(callMode),
|
|
videoEverActivated: false,
|
|
connectionRouteLabel: '',
|
|
reconnectInProgress: false,
|
|
reconnectAttempts: 0,
|
|
debugMode: false,
|
|
debugRunId: '',
|
|
debugRole: '',
|
|
pendingRemoteIceCandidates: [],
|
|
pendingNegotiationReason: '',
|
|
initialOfferInProgress: false,
|
|
initialOfferSent: false,
|
|
timelineEvents: [],
|
|
timelineSeq: 0,
|
|
timelineBaseMs: nowMs(),
|
|
};
|
|
calls.set(callId, call);
|
|
activeCallId = callId;
|
|
recordCallTimeline(call, 'outgoing_created', `peer=${cleanPeer}`);
|
|
setStatus(call, t('remaining.call.finding_user'), 'searching');
|
|
|
|
call.timers.total35s = setTimeout(() => {
|
|
if (!calls.has(callId)) return;
|
|
if (!call.connectedAtMs) {
|
|
recordCallTimeline(call, 'total_timeout_fired', 'total_timeout_35s', 'warn');
|
|
void finalizeCall(call, { localReasonCode: 'no_answer', debugReason: 'total_timeout_35s' });
|
|
}
|
|
}, 35000);
|
|
|
|
try {
|
|
call.inviteDelivery = await broadcastSignal(call, TYPES.INVITE, buildInviteData({ mode: callMode }));
|
|
recordCallTimeline(
|
|
call,
|
|
'invite_broadcast_ok',
|
|
`ws=${Number(call.inviteDelivery?.deliveredWsSessions || 0)}; push=${Number(call.inviteDelivery?.deliveredWebPushSessions || call.inviteDelivery?.deliveredFcmSessions || 0)}`,
|
|
);
|
|
if (getInviteDeliveredCount(call) > 0 && call.phase === 'searching') {
|
|
setStatus(call, t('remaining.call.calling'), 'ringing');
|
|
}
|
|
scheduleOutgoingAckTimeout(call);
|
|
} catch (error) {
|
|
recordCallTimeline(call, 'invite_broadcast_failed', toErrorText(error), 'warn');
|
|
const text = String(error?.message || '').toUpperCase();
|
|
const isNotAuth = text.includes('NOT_AUTHENTICATED');
|
|
if (isNotAuth) {
|
|
const recovered = await ensureSessionForCall({ timeoutMs: preflightTimeoutMs, force: true });
|
|
if (recovered) {
|
|
try {
|
|
call.inviteDelivery = await broadcastSignal(call, TYPES.INVITE, buildInviteData({ mode: callMode }));
|
|
if (getInviteDeliveredCount(call) > 0 && call.phase === 'searching') {
|
|
setStatus(call, t('remaining.call.calling'), 'ringing');
|
|
}
|
|
scheduleOutgoingAckTimeout(call);
|
|
return;
|
|
} catch {}
|
|
}
|
|
await finalizeCall(call, { localReasonCode: 'error', debugReason: 'invite_failed:not_authenticated_after_retry' });
|
|
throw new Error(t('remaining.call.server_temporarily_unavailable'));
|
|
}
|
|
await finalizeCall(call, { localReasonCode: 'error', debugReason: `invite_failed:${toErrorText(error)}` });
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
export async function handleIncomingCallInvite(evt) {
|
|
await handleIncomingInvitePayload(evt?.payload || {}, { source: 'ws' });
|
|
}
|
|
|
|
export async function handleIncomingCallSignalViaSendSignal(evt) {
|
|
const payload = evt?.payload || {};
|
|
const signalType = String(payload?.signalType || '').trim();
|
|
if (!signalType.startsWith('call_')) return false;
|
|
|
|
const decoded = decodeCallSignalData(payload?.data || '');
|
|
if (!Number.isFinite(decoded.type)) return true;
|
|
|
|
const normalizedEvent = {
|
|
payload: {
|
|
callId: decoded.callId || String(payload?.signalRequestId || '').trim(),
|
|
fromLogin: payload?.fromLogin,
|
|
fromSessionId: payload?.fromSessionId,
|
|
type: decoded.type,
|
|
data: decoded.data,
|
|
},
|
|
};
|
|
|
|
if (decoded.type === TYPES.INVITE || decoded.type === TYPES.CONNECT_START) {
|
|
await handleIncomingInvitePayload(normalizedEvent.payload, { source: 'send_signal' });
|
|
return true;
|
|
}
|
|
|
|
await handleIncomingCallSignal(normalizedEvent);
|
|
return true;
|
|
}
|
|
|
|
export async function acceptIncomingCall() {
|
|
const call = getActiveCall();
|
|
if (!call || call.direction !== 'in' || call.phase !== 'incoming') return;
|
|
recordCallTimeline(call, 'incoming_accept_clicked', `session=${call.remoteSessionId || ''}`);
|
|
if (call.autoEnableCameraOnConnect) {
|
|
call.cameraEnabled = true;
|
|
}
|
|
call.phase = 'connecting';
|
|
setStatus(call, t('remaining.call.connecting'), 'connecting');
|
|
cleanupTimers(call);
|
|
scheduleIncomingConnectTimeout(call);
|
|
await sendSignal(call, TYPES.ACCEPT, 'accept');
|
|
}
|
|
|
|
export async function declineIncomingCall() {
|
|
const call = getActiveCall();
|
|
if (!call || call.direction !== 'in' || call.phase !== 'incoming') return;
|
|
dismissCallUiLocally(call);
|
|
const declinePromise = (async () => {
|
|
try {
|
|
await sendSignal(call, TYPES.DECLINE_BUSY, 'decline');
|
|
} catch {}
|
|
})();
|
|
await finalizeCall(call, {
|
|
localReasonCode: 'declined',
|
|
debugReason: 'declined_by_user',
|
|
suppressRemoteSignal: true,
|
|
});
|
|
await declinePromise;
|
|
}
|
|
|
|
export async function handleIncomingCallSignal(evt) {
|
|
const payload = evt?.payload || {};
|
|
const callId = String(payload.callId || '').trim();
|
|
const fromLogin = String(payload.fromLogin || '').trim();
|
|
const fromSessionId = String(payload.fromSessionId || '').trim();
|
|
const type = Number(payload.type);
|
|
const data = String(payload.data || '');
|
|
if (!callId || !fromLogin || !Number.isFinite(type)) return;
|
|
|
|
const call = getCall(callId);
|
|
if (!call) return;
|
|
const signalName = getSignalTypeName(type);
|
|
recordCallTimeline(call, `signal_in_${signalName}`, `from=${fromSessionId || '-'}; len=${data.length}`);
|
|
if (call.direction === 'out') {
|
|
if (type === TYPES.RINGING) {
|
|
recordCallTimeline(call, 'ringing_received', `from=${fromSessionId || '-'}`);
|
|
} else if (type === TYPES.ACCEPT) {
|
|
if (fromSessionId) {
|
|
if (!call.remoteSessionId) {
|
|
setRemoteSessionId(call, fromSessionId, 'accept');
|
|
} else if (call.remoteSessionId !== fromSessionId) {
|
|
recordCallTimeline(call, 'signal_in_accept_ignored', `selected=${call.remoteSessionId}; from=${fromSessionId}`, 'warn');
|
|
await emitDebug(
|
|
call,
|
|
'warn',
|
|
'accept_from_non_selected_session_ignored',
|
|
`selected=${call.remoteSessionId}; from=${fromSessionId}`,
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
const remoteSessionLocked = Boolean(
|
|
call.initialOfferSent
|
|
|| call.connectedAtMs
|
|
|| call.phase === 'connecting'
|
|
|| call.phase === 'active'
|
|
|| call.phase === 'reconnecting',
|
|
);
|
|
const terminalSignalFromAnotherSession =
|
|
Boolean(call.remoteSessionId)
|
|
&& Boolean(fromSessionId)
|
|
&& call.remoteSessionId !== fromSessionId
|
|
&& (type === TYPES.DECLINE_BUSY || type === TYPES.TIMEOUT || type === TYPES.HANGUP);
|
|
if (call.remoteSessionId && fromSessionId && call.remoteSessionId !== fromSessionId) {
|
|
if (terminalSignalFromAnotherSession && !remoteSessionLocked) {
|
|
recordCallTimeline(call, 'terminal_signal_before_lock_allowed', `type=${signalName}; selected=${call.remoteSessionId}; from=${fromSessionId}`);
|
|
await emitDebug(
|
|
call,
|
|
'info',
|
|
'terminal_signal_from_non_selected_session_allowed_before_lock',
|
|
`type=${type}; selected=${call.remoteSessionId}; from=${fromSessionId}`,
|
|
);
|
|
} else {
|
|
recordCallTimeline(call, 'signal_in_ignored_non_selected_session', `type=${signalName}; selected=${call.remoteSessionId}; from=${fromSessionId}`);
|
|
await emitDebug(
|
|
call,
|
|
'info',
|
|
'signal_from_non_selected_session_ignored',
|
|
`type=${type}; selected=${call.remoteSessionId}; from=${fromSessionId}`,
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
if (!call.remoteSessionId && fromSessionId) {
|
|
setRemoteSessionId(call, fromSessionId, `first_${signalName}`);
|
|
}
|
|
}
|
|
} else if (!call.remoteSessionId) {
|
|
setRemoteSessionId(call, fromSessionId, `incoming_${signalName}`);
|
|
}
|
|
|
|
if (type === TYPES.RINGING) {
|
|
if (call.direction === 'out' && call.phase === 'searching') {
|
|
setStatus(call, t('remaining.call.calling'), 'ringing');
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.CONNECT_START) {
|
|
const winnerSessionId = parseConnectStartWinnerSessionId(data);
|
|
recordCallTimeline(call, 'connect_start_received', `winnerSession=${winnerSessionId || '-'}; currentRemoteSession=${call.remoteSessionId || '-'}`);
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.ACCEPT) {
|
|
if (call.direction !== 'out') {
|
|
await emitDebug(call, 'warn', 'accept_ignored_for_non_outgoing_call', `direction=${call.direction || ''}`);
|
|
return;
|
|
}
|
|
call.phase = 'connecting';
|
|
setStatus(call, t('remaining.call.connecting'), 'connecting');
|
|
await onAccept(call);
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.DECLINE_BUSY) {
|
|
const normalized = data.trim().toLowerCase();
|
|
const isDeclined = normalized === 'decline' || normalized === 'declined';
|
|
await finalizeCall(call, {
|
|
localReasonCode: isDeclined ? 'declined' : 'busy',
|
|
debugReason: isDeclined ? 'declined_by_remote' : 'busy_by_remote',
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.TIMEOUT) {
|
|
await finalizeCall(call, { localReasonCode: 'no_answer', debugReason: 'remote_timeout' });
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.HANGUP) {
|
|
await finalizeCall(call, {
|
|
localReasonCode: call.connectedAtMs ? 'completed' : 'no_answer',
|
|
debugReason: 'remote_hangup',
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.OFFER) {
|
|
try {
|
|
recordCallTimeline(call, 'offer_processing_start', `from=${fromSessionId || '-'}`);
|
|
const pc = await ensurePeerConnection(call);
|
|
const incomingOffer = new RTCSessionDescription(JSON.parse(data));
|
|
const localType = String(pc.localDescription?.type || '').trim().toLowerCase();
|
|
if (pc.signalingState !== 'stable' && localType === 'offer') {
|
|
recordCallTimeline(call, 'offer_glare_rollback', `state=${pc.signalingState}; from=${fromSessionId || '-'}`);
|
|
await pc.setLocalDescription({ type: 'rollback' });
|
|
}
|
|
await pc.setRemoteDescription(incomingOffer);
|
|
if (hasVideoSectionInSdp(incomingOffer?.sdp || '')) {
|
|
if (call.videoTransportMode === VIDEO_TRANSPORT_SLOT) {
|
|
ensureReservedVideoTransceiver(call);
|
|
if (!call.videoSender) {
|
|
await ensureVideoSenderSlot(call, { sourceTrack: ensureBlackVideoTrack(call), profile: 'placeholder' });
|
|
}
|
|
} else if (call.videoTransportMode === VIDEO_TRANSPORT_RESERVED) {
|
|
ensureReservedVideoTransceiver(call);
|
|
} else {
|
|
call.videoTransportMode = VIDEO_TRANSPORT_RESERVED;
|
|
ensureReservedVideoTransceiver(call);
|
|
}
|
|
if (call.videoTransportMode === VIDEO_TRANSPORT_SLOT && !call.videoSender) {
|
|
await ensureVideoSenderSlot(call, { sourceTrack: ensureBlackVideoTrack(call), profile: 'placeholder' });
|
|
}
|
|
if (call.autoEnableCameraOnConnect && call.cameraEnabled) {
|
|
try {
|
|
await applyCameraState(call);
|
|
} catch {}
|
|
}
|
|
}
|
|
syncRemoteReceiverVideoTracks(call);
|
|
await flushPendingIceCandidates(call);
|
|
const answer = await pc.createAnswer();
|
|
await pc.setLocalDescription(answer);
|
|
await sendSignal(call, TYPES.ANSWER, JSON.stringify(answer));
|
|
refreshVideoSlotReady(call);
|
|
setStatus(call, t('remaining.call.connecting'), 'connecting');
|
|
notifyCallState();
|
|
await emitDebug(call, 'info', 'offer_processed', 'answer sent');
|
|
} catch (error) {
|
|
await emitDebug(call, 'error', 'offer_process_failed', toErrorText(error));
|
|
await finalizeCall(call, { localReasonCode: 'error', debugReason: `offer_failed:${toErrorText(error)}` });
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.ANSWER) {
|
|
try {
|
|
if (call.direction !== 'out') {
|
|
await emitDebug(call, 'warn', 'answer_ignored_for_non_outgoing_call', `direction=${call.direction || ''}`);
|
|
return;
|
|
}
|
|
if (!call.pc) {
|
|
await emitDebug(call, 'warn', 'answer_ignored_without_pc', 'no local peer connection');
|
|
return;
|
|
}
|
|
const pc = call.pc;
|
|
const localType = String(pc.localDescription?.type || '').trim().toLowerCase();
|
|
if (localType !== 'offer') {
|
|
await emitDebug(call, 'warn', 'answer_ignored_without_local_offer', `localType=${localType || 'none'}`);
|
|
return;
|
|
}
|
|
if (pc.signalingState === 'stable' && pc.remoteDescription) {
|
|
await emitDebug(call, 'warn', 'answer_duplicate_ignored', 'remote description already set');
|
|
return;
|
|
}
|
|
await pc.setRemoteDescription(new RTCSessionDescription(JSON.parse(data)));
|
|
if (hasVideoSectionInSdp(pc.remoteDescription?.sdp || '')) {
|
|
if (!call.videoTransportMode || call.videoTransportMode === VIDEO_TRANSPORT_NONE) {
|
|
call.videoTransportMode = VIDEO_TRANSPORT_RESERVED;
|
|
}
|
|
ensureReservedVideoTransceiver(call);
|
|
}
|
|
syncRemoteReceiverVideoTracks(call);
|
|
await flushPendingIceCandidates(call);
|
|
refreshVideoSlotReady(call);
|
|
recordCallTimeline(call, 'answer_applied', `from=${fromSessionId || '-'}`);
|
|
setStatus(call, t('remaining.call.connecting'), 'connecting');
|
|
notifyCallState();
|
|
await emitDebug(call, 'info', 'answer_processed', 'remote description set');
|
|
} catch (error) {
|
|
await emitDebug(call, 'error', 'answer_process_failed', toErrorText(error));
|
|
await finalizeCall(call, { localReasonCode: 'error', debugReason: `answer_failed:${toErrorText(error)}` });
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (type === TYPES.ICE) {
|
|
try {
|
|
const candidate = JSON.parse(data);
|
|
call.remoteIceReceivedCount = Number(call.remoteIceReceivedCount || 0) + 1;
|
|
if (!call.pc) {
|
|
if (!Array.isArray(call.pendingRemoteIceCandidates)) call.pendingRemoteIceCandidates = [];
|
|
call.pendingRemoteIceCandidates.push(candidate);
|
|
if (call.remoteIceReceivedCount <= 3) {
|
|
recordCallTimeline(call, 'ice_remote_queued_no_pc', `count=${call.remoteIceReceivedCount}; queue=${call.pendingRemoteIceCandidates.length}`);
|
|
}
|
|
await emitDebug(call, 'info', 'ice_queued_before_pc', `queue=${call.pendingRemoteIceCandidates.length}`);
|
|
return;
|
|
}
|
|
const pc = call.pc;
|
|
if (!pc.remoteDescription) {
|
|
if (!Array.isArray(call.pendingRemoteIceCandidates)) call.pendingRemoteIceCandidates = [];
|
|
call.pendingRemoteIceCandidates.push(candidate);
|
|
if (call.remoteIceReceivedCount <= 3) {
|
|
recordCallTimeline(call, 'ice_remote_queued_no_remote_description', `count=${call.remoteIceReceivedCount}; queue=${call.pendingRemoteIceCandidates.length}`);
|
|
}
|
|
await emitDebug(call, 'info', 'ice_queued_before_remote_description', `queue=${call.pendingRemoteIceCandidates.length}`);
|
|
return;
|
|
}
|
|
await pc.addIceCandidate(new RTCIceCandidate(candidate));
|
|
if (call.remoteIceReceivedCount <= 3) {
|
|
recordCallTimeline(call, 'ice_remote_applied', `count=${call.remoteIceReceivedCount}`);
|
|
}
|
|
await emitDebug(call, 'info', 'ice_processed', 'candidate added');
|
|
} catch (error) {
|
|
await emitDebug(call, 'error', 'ice_process_failed', toErrorText(error));
|
|
}
|
|
}
|
|
}
|
|
|
|
export async function hangupActiveCall() {
|
|
if (!activeCallId) return;
|
|
const call = getCall(activeCallId);
|
|
dismissCallUiLocally(call);
|
|
recordCallTimeline(call, 'hangup_clicked', `connected=${Boolean(call?.connectedAtMs)}`);
|
|
await finalizeCall(call, {
|
|
localReasonCode: call?.connectedAtMs ? 'completed' : 'no_answer',
|
|
debugReason: 'hangup_by_user',
|
|
notifyRemoteHangup: true,
|
|
});
|
|
}
|
|
|
|
export async function handleIncomingCallPush(payload = {}) {
|
|
if (!isCallPushForCurrentSession(payload)) return;
|
|
if (!isIncomingCallPushFresh(payload)) return;
|
|
await handleIncomingInvitePayload(payload, { source: 'push' });
|
|
}
|
|
|
|
export async function handleStopCallPush(payload = {}) {
|
|
if (!isCallPushForCurrentSession(payload)) return;
|
|
const callId = String(payload?.callId || '').trim();
|
|
if (!callId) return;
|
|
const call = getCall(callId);
|
|
if (!call) return;
|
|
const fromSessionId = String(payload?.fromSessionId || '').trim();
|
|
const reason = String(payload?.reason || 'stop_call_push').trim() || 'stop_call_push';
|
|
const currentSessionId = String(state?.session?.sessionId || '').trim();
|
|
if (fromSessionId && currentSessionId && fromSessionId === currentSessionId) {
|
|
await emitDebug(call, 'info', 'stop_call_push_ignored_for_origin_session', reason);
|
|
return;
|
|
}
|
|
recordCallTimeline(call, 'stop_call_push', `fromSession=${fromSessionId || '-'}; reason=${reason}`);
|
|
await finalizeCall(call, {
|
|
localReasonCode: call.connectedAtMs ? 'completed' : 'no_answer',
|
|
debugReason: `stop_call_push:${reason}`,
|
|
suppressRemoteSignal: true,
|
|
suppressReports: true,
|
|
suppressSummary: true,
|
|
});
|
|
}
|
|
|
|
export async function handleCallPushAction(action, payload = {}) {
|
|
if (!isCallPushForCurrentSession(payload)) return;
|
|
const normalized = String(action || '').trim().toLowerCase();
|
|
if (normalized !== 'accept' && normalized !== 'decline') return;
|
|
if (!isIncomingCallPushFresh(payload)) return;
|
|
const timeoutMs = resolveCallPreflightTimeoutMs();
|
|
const ok = await ensureSessionForCall({ timeoutMs, force: false });
|
|
if (!ok) {
|
|
throw new Error(t('remaining.call.could_not_connect_call_ended'));
|
|
}
|
|
await handleIncomingCallPush(payload);
|
|
if (normalized === 'accept') {
|
|
await acceptIncomingCall();
|
|
return;
|
|
}
|
|
await declineIncomingCall();
|
|
}
|