@wazo/sdk 0.43.6 → 1.0.0-alpha.0

package/esm/utils/webrtc.js

@@ -1,3 +1,25 @@
+import { defaultPeerConnectionConfiguration } from 'sip.js/lib/platform/web/session-description-handler/peer-connection-configuration-default';
+import { stripVideo } from 'sip.js/lib/platform/web';
+import WazoSessionDescriptionHandler, { wazoMediaStreamFactory } from '../lib/WazoSessionDescriptionHandler';
+import { getVideoDirection, hasAnActiveVideo, makeURI, replaceLocalIpModifier } from './sdp';
+import IssueReporter from '../service/IssueReporter';
+import { lastIndexOf } from './array';
+const logger = IssueReporter.loggerFor('webrtc');
+// setting a 24hr timeout and letting the backend define the actual value
+const NO_ANSWER_TIMEOUT = 60 * 60 * 24; // in seconds
+const DEFAULT_ICE_TIMEOUT = 3000;
+const privateIpRegex = /^(?:10|127|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168)\..*/;
+export const isWeb = () => typeof window === 'object' && typeof document === 'object';
+export const isFirefox = () => isWeb() && navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
+export const isAPrivateIp = (ip) => privateIpRegex.exec(ip) == null;
+export const getIceServers = (ip) => {
+    if (isAPrivateIp(ip)) {
+        return [{
+                urls: ['stun:stun.l.google.com:19302', 'stun:stun4.l.google.com:19302'],
+            }];
+    }
+    return [];
+};
 export const parseCandidate = (line) => {
     let parts;
     // Parse both variants.
@@ -35,3 +57,446 @@ export const parseCandidate = (line) => {
     }
     return candidate;
 };
+export const getPeerConnection = (sipCall) => {
+    if (!sipCall) {
+        return null;
+    }
+    return sipCall.sessionDescriptionHandler ? sipCall.sessionDescriptionHandler.peerConnection : null;
+};
+export const getLocalStream = (sipCall) => {
+    return sipCall?.sessionDescriptionHandler?.localMediaStream || null;
+};
+export const getLocalTracks = (sipCall) => {
+    const localStream = getLocalStream(sipCall);
+    if (!localStream) {
+        return [];
+    }
+    return localStream.getTracks();
+};
+export const getRemoteStream = (sipCall) => {
+    return sipCall?.sessionDescriptionHandler?.remoteMediaStream || null;
+};
+export const isVideoTrack = (track) => track.kind === 'video' && track.readyState === 'live';
+export const hasLocalVideo = (sipCall) => getLocalTracks(sipCall).some(isVideoTrack);
+export const hasALocalVideoTrack = (sipCall) => getLocalTracks(sipCall).some(track => track.kind === 'video');
+export const getLocalVideoStream = (sipCall) => (hasLocalVideo(sipCall) ? getLocalStream(sipCall) : null);
+export const getRemoteTracks = (sipCall) => {
+    const remoteStream = getRemoteStream(sipCall);
+    if (!remoteStream) {
+        return [];
+    }
+    return remoteStream.getTracks();
+};
+export const isVideoRemotelyHeld = (sipCall) => {
+    const pc = getPeerConnection(sipCall);
+    const sdp = pc && pc.remoteDescription ? pc.remoteDescription.sdp : null;
+    if (!sdp) {
+        return false;
+    }
+    const videoDirection = getVideoDirection(sdp);
+    return videoDirection === 'sendonly';
+};
+export const hasRemoteVideo = (sipCall) => getRemoteTracks(sipCall).some(isVideoTrack);
+export const hasARemoteVideoTrack = (sipCall) => getRemoteTracks(sipCall).some(track => track.kind === 'video');
+export const getRemoteVideoStream = (sipCall) => {
+    if (isVideoRemotelyHeld(sipCall)) {
+        return null;
+    }
+    return hasRemoteVideo(sipCall) ? getRemoteStream(sipCall) : null;
+};
+export const getRemoteVideoStreamFromPc = (sipCall) => {
+    const pc = getPeerConnection(sipCall);
+    if (!pc) {
+        return null;
+    }
+    return pc.getRemoteStreams().find((stream) => !!stream.getVideoTracks().length);
+};
+export const hasVideoTrack = (sipCall) => hasLocalVideo(sipCall) || hasRemoteVideo(sipCall);
+export const hasAVideoTrack = (sipCall) => hasALocalVideoTrack(sipCall) || hasARemoteVideoTrack(sipCall);
+// eslint-disable-next-line no-unused-vars
+export const sessionWantsToDoVideo = (sipCall) => {
+    if (!sipCall) {
+        return false;
+    }
+    const { body, } = sipCall.request || sipCall;
+    // Sometimes with InviteClientContext the body is in the body attribute ...
+    const sdp = typeof body === 'object' && body ? body.body : body;
+    return hasAnActiveVideo(sdp);
+};
+export const getWebRtcStats = async (sipCall) => {
+    const pc = getPeerConnection(sipCall);
+    if (!pc) {
+        return null;
+    }
+    return pc.getStats(null);
+};
+export const toggleAudio = (sipCall, muteAudio) => {
+    const sdh = sipCall.sessionDescriptionHandler;
+    const pc = (sdh?.peerConnection || null);
+    if (!pc) {
+        return;
+    }
+    if (pc.getSenders) {
+        pc.getSenders().forEach((sender) => {
+            if (sender && sender.track && sender.track.kind === 'audio') {
+                // eslint-disable-next-line
+                sender.track.enabled = !muteAudio;
+            }
+        });
+    }
+    else {
+        pc.getLocalStreams().forEach((stream) => {
+            stream.getAudioTracks().forEach(track => {
+                // eslint-disable-next-line
+                track.enabled = !muteAudio;
+            });
+        });
+    }
+};
+export const toggleVideo = (sipCall, muteCamera) => {
+    const sdh = sipCall.sessionDescriptionHandler;
+    const pc = sdh?.peerConnection;
+    if (pc?.getSenders) {
+        pc.getSenders().forEach((sender) => {
+            if (sender && sender.track && sender.track.kind === 'video') {
+                // eslint-disable-next-line
+                sender.track.enabled = !muteCamera;
+            }
+        });
+    }
+    else {
+        pc.getLocalStreams().forEach((stream) => {
+            stream.getVideoTracks().forEach(track => {
+                // eslint-disable-next-line
+                track.enabled = !muteCamera;
+            });
+        });
+    }
+};
+export const cleanupStream = (stream) => {
+    stream.getTracks().filter(track => track.enabled).forEach(track => track.stop());
+};
+export const setLocalMediaStream = (sipCall, newStream) => {
+    logger.info('setting local media stream', {
+        id: sipCall.id,
+        tracks: newStream ? newStream.getTracks() : null,
+    });
+    if (sipCall.sessionDescriptionHandler) {
+        // eslint-disable-next-line no-underscore-dangle
+        // @ts-ignore: protected
+        sipSession.sessionDescriptionHandler._localMediaStream = newStream;
+    }
+};
+export const updateRemoteStream = (sipCall, allTracks = true) => {
+    const remoteStream = getRemoteStream(sipCall);
+    const pc = getPeerConnection(sipCall);
+    logger.info('Updating remote stream', {
+        id: sipCall.id,
+        tracks: remoteStream ? remoteStream.getTracks() : null,
+        receiverTracks: pc && pc.getReceivers ? pc.getReceivers().map((receiver) => receiver.track) : null,
+    });
+    if (!pc || !remoteStream) {
+        return;
+    }
+    remoteStream.getTracks().forEach(track => {
+        if (allTracks || track.kind === 'video') {
+            remoteStream.removeTrack(track);
+        }
+    });
+    if (pc.getReceivers) {
+        pc.getReceivers().forEach((receiver) => {
+            if (allTracks || receiver.track.kind === 'video') {
+                remoteStream.addTrack(receiver.track);
+            }
+        });
+    }
+};
+export const isAudioOnly = (sipCall) => {
+    return Boolean(sipCall.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === stripVideo));
+};
+// @ts-ignore: media constraints
+export const getAudioConstraints = (audio) => (audio?.deviceId?.exact ? audio : true);
+export const getVideoConstraints = (video = false) => {
+    if (!video) {
+        return false;
+    }
+    // @ts-ignore: media constraints
+    return this.video?.deviceId?.exact ? this.video : true;
+};
+// eslint-disable-next-line no-unused-vars
+const getRtcOptions = () => {
+    return {
+        mandatory: {
+            OfferToReceiveAudio: true,
+            OfferToReceiveVideo: false,
+        },
+    };
+};
+export const getMediaConfiguration = (enableVideo, conference = false, constraints = null) => {
+    const screenSharing = constraints && 'screen' in constraints ? constraints.screen : false;
+    const isDesktop = constraints && 'desktop' in constraints ? constraints.desktop : false;
+    const withAudio = constraints && 'audio' in constraints ? constraints.audio : true;
+    const mandatoryVideo = constraints && typeof constraints.video === 'object' ? constraints.video.mandatory : {};
+    logger.info('Retrieving media a configuration', { enableVideo, screenSharing, isDesktop, withAudio, constraints });
+    return {
+        constraints: {
+            // Exact constraint are not supported with `getDisplayMedia` and we must have a video=false in desktop screenshare
+            audio: screenSharing ? !isDesktop : constraints?.audio,
+            video: screenSharing ? isDesktop ? {
+                mandatory: {
+                    chromeMediaSource: 'desktop',
+                    ...(mandatoryVideo || {}),
+                },
+            } : {
+                cursor: 'always',
+            } : getVideoConstraints(enableVideo),
+            screen: screenSharing,
+            desktop: isDesktop,
+            conference,
+        },
+        enableVideo,
+        conference,
+        offerOptions: {
+            OfferToReceiveAudio: true,
+            OfferToReceiveVideo: enableVideo,
+            mandatory: {
+                OfferToReceiveAudio: true,
+                OfferToReceiveVideo: enableVideo,
+            },
+        },
+    };
+};
+export const getStreamFromConstraints = async (constraints, conference = false) => {
+    const video = constraints && constraints.video;
+    const { constraints: newConstraints } = getMediaConfiguration(video, conference, constraints);
+    let newStream = null;
+    try {
+        newStream = await wazoMediaStreamFactory(newConstraints);
+    }
+    catch (e) { // Nothing to do when the user cancel the screensharing prompt
+    }
+    if (!newStream) {
+        return null;
+    }
+    newStream.local = true;
+    return newStream;
+};
+export const createUaOptions = (config, uaOptionsOverrides = {}, audio = false, video = false) => {
+    let { host } = config;
+    let port = config.port || 443;
+    if (config.websocketSip) {
+        const webSocketSip = config.websocketSip.split(':');
+        [host] = webSocketSip;
+        port = Number(webSocketSip[1]);
+    }
+    const { userUuid } = config;
+    const uaOptions = {
+        noAnswerTimeout: NO_ANSWER_TIMEOUT,
+        authorizationUsername: config.authorizationUser,
+        authorizationPassword: config.password,
+        displayName: config.displayName,
+        hackIpInContact: true,
+        contactParams: {
+            transport: 'wss',
+        },
+        logBuiltinEnabled: config.log ? config.log.builtinEnabled : null,
+        logLevel: config.log ? config.log.logLevel : null,
+        logConnector: config.log ? config.log.connector : null,
+        uri: makeURI(config.authorizationUser || '', config.host),
+        userAgentString: config.userAgentString || 'wazo-sdk',
+        reconnectionAttempts: 10000,
+        reconnectionDelay: 5,
+        // @ts-ignore
+        sessionDescriptionHandlerFactory: (sipCall, options = {}) => {
+            const uaLogger = sipCall.userAgent.getLogger('sip.WazoSessionDescriptionHandler');
+            const iceGatheringTimeout = 'peerConnectionOptions' in options ? options.peerConnectionOptions.iceGatheringTimeout || DEFAULT_ICE_TIMEOUT : DEFAULT_ICE_TIMEOUT;
+            const sdhOptions = { ...options,
+                iceGatheringTimeout,
+                peerConnectionConfiguration: { ...defaultPeerConnectionConfiguration(),
+                    ...(options.peerConnectionConfiguration || {}),
+                },
+            };
+            return new WazoSessionDescriptionHandler(uaLogger, wazoMediaStreamFactory, sdhOptions, isWeb(), sipCall);
+        },
+        transportOptions: {
+            traceSip: uaOptionsOverrides?.traceSip || false,
+            wsServers: `wss://${host}:${port}/api/asterisk/ws${userUuid ? `?userUuid=${userUuid}` : ''}`,
+        },
+        sessionDescriptionHandlerFactoryOptions: {
+            modifiers: [replaceLocalIpModifier],
+            alwaysAcquireMediaFirst: isFirefox(),
+            constraints: {
+                audio: getAudioConstraints(audio),
+                video: getVideoConstraints(video),
+            },
+            peerConnectionOptions: {
+                iceCheckingTimeout: config.iceCheckingTimeout || 1000,
+                iceGatheringTimeout: config.iceCheckingTimeout || 1000,
+                rtcConfiguration: {
+                    rtcpMuxPolicy: 'require',
+                    iceServers: getIceServers(config.host),
+                    ...getRtcOptions(),
+                    ...(uaOptionsOverrides?.peerConnectionOptions || {}),
+                },
+            },
+            // Configuration used in SDH to create the PeerConnection
+            peerConnectionConfiguration: {
+                rtcpMuxPolicy: 'require',
+                iceServers: getIceServers(config.host),
+                ...(uaOptionsOverrides?.peerConnectionOptions || {}),
+            },
+        },
+    };
+    delete uaOptionsOverrides?.traceSip;
+    return {
+        ...uaOptions,
+        ...uaOptionsOverrides,
+    };
+};
+export const downgradeToAudio = (sipCall) => {
+    // Release local video stream when downgrading to audio
+    const sessionDescriptionHandler = sipCall.sessionDescriptionHandler;
+    const localStream = sessionDescriptionHandler?.localMediaStream;
+    const pc = sessionDescriptionHandler?.peerConnection;
+    const videoTracks = localStream.getVideoTracks();
+    // Remove video senders
+    if (pc?.getSenders) {
+        pc.getSenders().filter((sender) => sender.track && sender.track.kind === 'video').forEach((videoSender) => {
+            videoSender.replaceTrack(null);
+        });
+    }
+    videoTracks.forEach((videoTrack) => {
+        videoTrack.enabled = false;
+        videoTrack.stop();
+        localStream.removeTrack(videoTrack);
+    });
+};
+// Returns true if a re-INVITE is required
+export const upgradeToVideo = async (sipCall, constraints, isConference) => {
+    const pc = getPeerConnection(sipCall);
+    // Check if a video sender already exists
+    let videoSender;
+    if (isConference) {
+        // We search for the last transceiver without `video-` in the mid (video- means remote transceiver)
+        const transceivers = pc?.getTransceivers() || [];
+        const transceiverIdx = lastIndexOf(transceivers, transceiver => transceiver.sender.track === null && transceiver.mid && transceiver.mid.indexOf('video') === -1);
+        videoSender = transceiverIdx !== -1 ? transceivers[transceiverIdx].sender : null;
+    }
+    else {
+        videoSender = pc && pc.getSenders && pc.getSenders().find((sender) => sender.track === null);
+    }
+    if (!videoSender) {
+        // When no video sender found, it means that we're in the first video upgrade in 1:1
+        return;
+    }
+    // Reuse bidirectional video stream
+    const newStream = await getStreamFromConstraints(constraints);
+    if (!newStream) {
+        console.warn(`Can't create media stream with: ${JSON.stringify(constraints || {})}`);
+        return;
+    }
+    // Add previous local audio track
+    if (constraints && !constraints.audio) {
+        const localVideoStream = sipCall.sessionDescriptionHandler?.localMediaStream;
+        const localAudioTrack = localVideoStream.getTracks().find(track => track.kind === 'audio');
+        if (localAudioTrack) {
+            newStream.addTrack(localAudioTrack);
+        }
+    }
+    const videoTrack = newStream.getVideoTracks()[0];
+    if (videoTrack) {
+        videoSender.replaceTrack(videoTrack);
+    }
+    setLocalMediaStream(sipCall, newStream);
+    return newStream;
+};
+export const fetchNetworkStats = async (sipCall, lastNetworkStats) => {
+    const stats = sipCall ? await getWebRtcStats(sipCall) : null;
+    if (!stats) {
+        return Promise.resolve(null);
+    }
+    const networkStats = {
+        audioBytesSent: 0,
+        videoBytesSent: 0,
+        videoBytesReceived: 0,
+        audioBytesReceived: 0,
+    };
+    const lastAudioSent = lastNetworkStats ? lastNetworkStats.audioBytesSent : 0;
+    const lastAudioContentSent = lastNetworkStats ? lastNetworkStats.audioContentSent : 0;
+    const lastVideoSent = lastNetworkStats ? lastNetworkStats.videoBytesSent : 0;
+    const lastAudioReceived = lastNetworkStats ? lastNetworkStats.audioBytesReceived : 0;
+    const lastAudioContentReceived = lastNetworkStats ? lastNetworkStats.audioContentReceived : 0;
+    const lastVideoReceived = lastNetworkStats ? lastNetworkStats.videoBytesReceived : 0;
+    const lastTransportSent = lastNetworkStats ? lastNetworkStats.transportSent : 0;
+    const lastTransportReceived = lastNetworkStats ? lastNetworkStats.transportReceived : 0;
+    let audioBytesSent = 0; // content + header
+    let audioBytesReceived = 0; // content + header
+    let audioContentSent = 0; // useful to detect blank call
+    let audioContentReceived = 0;
+    let videoBytesSent = 0;
+    let videoBytesReceived = 0;
+    let transportSent = 0;
+    let transportReceived = 0;
+    let packetsLost = 0;
+    stats.forEach(report => {
+        if (report.type === 'outbound-rtp' && report.kind === 'audio') {
+            audioBytesSent += Number(report.bytesSent) + Number(report.headerBytesSent);
+            audioContentSent += Number(report.bytesSent);
+        }
+        if (report.type === 'remote-outbound-rtp' && report.kind === 'audio') {
+            audioBytesSent += Number(report.bytesSent);
+        }
+        if (report.type === 'outbound-rtp' && report.kind === 'video') {
+            videoBytesSent += Number(report.bytesSent) + Number(report.headerBytesSent);
+        }
+        if (report.type === 'inbound-rtp' && report.kind === 'audio') {
+            packetsLost += Number(report.packetsLost);
+            networkStats.packetsReceived = Number(report.packetsReceived);
+            audioBytesReceived += Number(report.bytesReceived) + Number(report.headerBytesReceived);
+            audioContentReceived += Number(report.bytesReceived);
+        }
+        if (report.type === 'inbound-rtp' && report.kind === 'video') {
+            videoBytesReceived += Number(report.bytesReceived) + Number(report.headerBytesReceived);
+        }
+        if (report.type === 'outbound-rtp' && report.kind === 'video') {
+            if ('framesPerSecond' in report) {
+                networkStats.framesPerSecond = Number(report.framesPerSecond);
+            }
+            if ('framerateMean' in report) {
+                // framerateMean is only available in FF
+                networkStats.framesPerSecond = Math.round(report.framerateMean);
+            }
+        }
+        if (report.type === 'remote-inbound-rtp' && report.kind === 'audio') {
+            packetsLost += Number(report.packetsLost);
+            networkStats.roundTripTime = Number(report.roundTripTime);
+            networkStats.jitter = Number(report.jitter);
+        }
+        if (report.type === 'remote-inbound-rtp' && report.kind === 'video') {
+            packetsLost += Number(report.packetsLost);
+        }
+        if (report.type === 'transport') {
+            transportSent += Number(report.bytesSent);
+            transportReceived += Number(report.bytesReceived);
+        }
+    });
+    networkStats.packetsLost = packetsLost;
+    networkStats.totalAudioBytesSent = audioBytesSent;
+    networkStats.audioBytesSent = audioBytesSent - lastAudioSent;
+    networkStats.totalAudioBytesReceived = audioBytesReceived - lastAudioReceived;
+    networkStats.audioBytesReceived = audioBytesReceived;
+    networkStats.totalAudioContentSent = audioContentSent;
+    networkStats.audioContentSent = audioContentSent - lastAudioContentSent;
+    networkStats.totalAudioBytesReceived = audioContentReceived - lastAudioContentReceived;
+    networkStats.audioContentReceived = audioContentReceived;
+    networkStats.totalVideoBytesSent = videoBytesSent;
+    networkStats.videoBytesSent = videoBytesSent - lastVideoSent;
+    networkStats.totalVideoBytesReceived = videoBytesReceived;
+    networkStats.videoBytesReceived = videoBytesReceived - lastVideoReceived;
+    networkStats.totalTransportSent = transportSent - lastTransportSent;
+    networkStats.transportSent = transportSent;
+    networkStats.totalTransportReceived = transportReceived;
+    networkStats.transportReceived = transportReceived - lastTransportReceived;
+    networkStats.bandwidth = networkStats.audioBytesSent + networkStats.audioBytesReceived + networkStats.videoBytesSent + networkStats.videoBytesReceived + networkStats.transportReceived + networkStats.transportSent;
+    return networkStats;
+};