@wazo/sdk 0.43.6 → 1.0.0-alpha.1

package/esm/web-rtc-client.js

@@ -1,5 +1,5 @@
 /* eslint-disable class-methods-use-this, no-param-reassign, max-classes-per-file, no-underscore-dangle */
-/* global window, document, navigator */
+/* global document, navigator */
 import 'webrtc-adapter';
 import { UserAgentState } from 'sip.js/lib/api/user-agent-state';
 import { Parser } from 'sip.js/lib/core/messages/parser';
@@ -11,23 +11,14 @@ import { Messager } from 'sip.js/lib/api/messager';
 import { RegistererState } from 'sip.js/lib/api/registerer-state';
 import { SessionState } from 'sip.js/lib/api/session-state';
 import { TransportState } from 'sip.js/lib/api/transport-state';
-import { defaultPeerConnectionConfiguration } from 'sip.js/lib/platform/web/session-description-handler/peer-connection-configuration-default';
 import getStats from 'getstats';
 import { Inviter, Invitation, Registerer } from 'sip.js/lib/api';
-import WazoSessionDescriptionHandler, { wazoMediaStreamFactory } from './lib/WazoSessionDescriptionHandler';
 import Emitter from './utils/Emitter';
 import ApiClient from './api-client';
 import IssueReporter from './service/IssueReporter';
 import Heartbeat from './utils/Heartbeat';
-import { getVideoDirection, hasAnActiveVideo } from './utils/sdp';
-import { lastIndexOf } from './utils/array';
-// We need to replace 0.0.0.0 to 127.0.0.1 in the sdp to avoid MOH during a createOffer.
-export const replaceLocalIpModifier = (description) => Promise.resolve({
-    ...JSON.parse(JSON.stringify(description)),
-    sdp: description.sdp.replace('c=IN IP4 0.0.0.0', 'c=IN IP4 127.0.0.1'),
-});
-const SIP_ID_LENGTH = 36;
-const DEFAULT_ICE_TIMEOUT = 3000;
+import { getSipSessionId, makeURI, replaceLocalIpModifier, SIP_ID_LENGTH } from './utils/sdp';
+import { cleanupStream, createUaOptions, fetchNetworkStats, getAudioConstraints, getLocalStream, getLocalTracks, getLocalVideoStream, getMediaConfiguration, getPeerConnection, getRemoteStream, getRemoteTracks, getRemoteVideoStream, getRemoteVideoStreamFromPc, getVideoConstraints, hasALocalVideoTrack, hasARemoteVideoTrack, hasAVideoTrack, hasLocalVideo, hasRemoteVideo, hasVideoTrack, isAudioOnly, isVideoRemotelyHeld, isWeb, sessionWantsToDoVideo, setLocalMediaStream, toggleAudio, toggleVideo, updateRemoteStream } from './utils/webrtc';
 const SEND_STATS_DELAY = 5000;
 const states = ['STATUS_NULL', 'STATUS_NEW', 'STATUS_CONNECTING', 'STATUS_CONNECTED', 'STATUS_COMPLETED'];
 const logger = IssueReporter ? IssueReporter.loggerFor('webrtc-client') : console;
@@ -56,8 +47,6 @@ export const transportEvents = [CONNECTED, DISCONNECTED, TRANSPORT_ERROR, MESSAG
 export class CanceledCallError extends Error {
 }
 const MAX_REGISTER_TRIES = 5;
-// setting a 24hr timeout and letting the backend define the actual value
-const NO_ANSWER_TIMEOUT = 60 * 60 * 24; // in seconds
 export default class WebRTCClient extends Emitter {
     clientId;
     config;
@@ -104,18 +93,6 @@ export default class WebRTCClient extends Emitter {
     ON_EARLY_MEDIA;
     ON_PROGRESS;
     ON_DISCONNECTED;
-    static isAPrivateIp(ip) {
-        const regex = /^(?:10|127|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168)\..*/;
-        return regex.exec(ip) == null;
-    }
-    static getIceServers(ip) {
-        if (WebRTCClient.isAPrivateIp(ip)) {
-            return [{
-                    urls: ['stun:stun.l.google.com:19302', 'stun:stun4.l.google.com:19302'],
-                }];
-        }
-        return [];
-    }
     constructor(config, session, uaConfigOverrides) {
         super();
         // For debug purpose
@@ -179,7 +156,7 @@ export default class WebRTCClient extends Emitter {
         this.audio = media.audio;
     }
     createUserAgent(uaConfigOverrides) {
-        const uaOptions = this._createUaOptions(uaConfigOverrides);
+        const uaOptions = createUaOptions(this.config, uaConfigOverrides, this.audio, this.video);
         logger.info('sdk webrtc, creating UA', {
             uaOptions: { ...uaOptions, authorizationPassword: `${uaOptions?.authorizationPassword?.slice(0, 5)}xxxx` },
             clientId: this.clientId,
@@ -196,7 +173,7 @@ export default class WebRTCClient extends Emitter {
                 });
                 this._setupSession(invitation);
                 const shouldAutoAnswer = !!invitation.request.getHeader('alert-info');
-                this.eventEmitter.emit(INVITE, invitation, this.sessionWantsToDoVideo(invitation), shouldAutoAnswer);
+                this.eventEmitter.emit(INVITE, invitation, sessionWantsToDoVideo(invitation), shouldAutoAnswer);
             },
         };
         const ua = new UserAgent(uaOptions);
@@ -287,7 +264,7 @@ export default class WebRTCClient extends Emitter {
             logger.info('sdk webrtc registering aborted due to a registration in progress.', { clientId: this.clientId });
             return Promise.resolve();
         }
-        const registerOptions = this._isWeb() ? {} : {
+        const registerOptions = isWeb() ? {} : {
             extraContactHeaderParams: ['mobility=mobile'],
         };
         const onRegisterFailed = () => {
@@ -445,7 +422,7 @@ export default class WebRTCClient extends Emitter {
         if (audioOnly) {
             inviterOptions.sessionDescriptionHandlerModifiersReInvite = [stripVideo];
         }
-        const uri = this._makeURI(number);
+        const uri = makeURI(number, this.config.host);
         let session = null;
         if (uri) {
             session = this.userAgent ? new Inviter(this.userAgent, uri, inviterOptions) : null;
@@ -458,7 +435,7 @@ export default class WebRTCClient extends Emitter {
             this._setupSession(session);
         }
         if (conference) {
-            this.conferences[this.getSipSessionId(session)] = true;
+            this.conferences[getSipSessionId(session)] = true;
         }
         const inviteOptions = {
             requestDelegate: {
@@ -482,7 +459,7 @@ export default class WebRTCClient extends Emitter {
                     this.eventEmitter.emit(REJECTED, session, response);
                 },
             },
-            sessionDescriptionHandlerOptions: this.getMediaConfiguration(enableVideo || false, conference),
+            sessionDescriptionHandlerOptions: getMediaConfiguration(enableVideo || false, conference),
         };
         if (inviteOptions.sessionDescriptionHandlerOptions) {
             inviteOptions.sessionDescriptionHandlerOptions.audioOnly = audioOnly;
@@ -512,7 +489,7 @@ export default class WebRTCClient extends Emitter {
             return Promise.reject(new Error(error));
         }
         const options = {
-            sessionDescriptionHandlerOptions: this.getMediaConfiguration(enableVideo || false),
+            sessionDescriptionHandlerOptions: getMediaConfiguration(enableVideo || false),
         };
         return this._accept(session, options).then(() => {
             // @ts-ignore: private
@@ -537,7 +514,7 @@ export default class WebRTCClient extends Emitter {
         try {
             this._stopSendingStats(session);
             this._cleanupMedia(session);
-            delete this.sipSessions[this.getSipSessionId(session)];
+            delete this.sipSessions[getSipSessionId(session)];
             // Check if Invitation or Inviter (Invitation = incoming call)
             const isInviter = session instanceof Inviter;
             // @see github.com/onsip/SIP.js/blob/f11dfd584bc9788ccfc94e03034020672b738975/src/platform/web/simple-user/simple-user.ts#L1004
@@ -557,16 +534,9 @@ export default class WebRTCClient extends Emitter {
         }
         return Promise.resolve(null);
     }
-    async getStats(session) {
-        const pc = session.sessionDescriptionHandler?.peerConnection;
-        if (!pc) {
-            return null;
-        }
-        return pc.getStats(null);
-    }
     // Fetch and emit an event at `interval` with session network stats
     startNetworkMonitoring(session, interval = 1000) {
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         logger.info('starting network inspection', {
             id: sessionId,
             clientId: this.clientId,
@@ -575,7 +545,7 @@ export default class WebRTCClient extends Emitter {
         this.networkMonitoringInterval[sessionId] = setInterval(() => this._fetchNetworkStats(sessionId), interval);
     }
     stopNetworkMonitoring(session) {
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         const exists = (sessionId in this.networkMonitoringInterval);
         logger.info('stopping network inspection', {
             clientId: this.clientId,
@@ -643,24 +613,17 @@ export default class WebRTCClient extends Emitter {
         this.userAgent = null;
         logger.info('sdk webrtc client closed', { clientId: this.clientId });
     }
-    getNumber(session) {
-        if (!session) {
-            return null;
-        }
-        // @ts-ignore: private
-        return session.remoteIdentity.uri._normal.user;
-    }
     mute(session) {
         logger.info('sdk webrtc mute', {
             id: session.id,
         });
-        this._toggleAudio(session, true);
+        toggleAudio(session, true);
     }
     unmute(session) {
         logger.info('sdk webrtc unmute', {
             id: session.id,
         });
-        this._toggleAudio(session, false);
+        toggleAudio(session, false);
     }
     isAudioMuted(session) {
         if (!session || !session.sessionDescriptionHandler) {
@@ -697,16 +660,16 @@ export default class WebRTCClient extends Emitter {
         logger.info('sdk webrtc toggle camera on', {
             id: session.id,
         });
-        this._toggleVideo(session, false);
+        toggleVideo(session, false);
     }
     toggleCameraOff(session) {
         logger.info('sdk webrtc toggle camera off', {
             id: session.id,
         });
-        this._toggleVideo(session, true);
+        toggleVideo(session, true);
     }
     hold(session, isConference = false, hadVideo = false) {
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         const hasVideo = hadVideo || this.hasLocalVideo(sessionId);
         logger.info('sdk webrtc hold', {
             sessionId,
@@ -734,8 +697,8 @@ export default class WebRTCClient extends Emitter {
             hold: true,
             conference: isConference,
         };
-        const options = this.getMediaConfiguration(false, isConference);
-        if (!this._isWeb()) {
+        const options = getMediaConfiguration(false, isConference);
+        if (!isWeb()) {
             options.sessionDescriptionHandlerModifiers = [holdModifier];
         }
         options.sessionDescriptionHandlerOptions = {
@@ -754,7 +717,7 @@ export default class WebRTCClient extends Emitter {
         });
     }
     unhold(session, isConference = false) {
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         const hasVideo = sessionId in this.heldSessions && this.heldSessions[sessionId].hasVideo;
         logger.info('sdk webrtc unhold', {
             sessionId,
@@ -769,13 +732,13 @@ export default class WebRTCClient extends Emitter {
             return Promise.resolve();
         }
         this.unmute(session);
-        delete this.heldSessions[this.getSipSessionId(session)];
+        delete this.heldSessions[getSipSessionId(session)];
         session.sessionDescriptionHandlerOptionsReInvite = {
             hold: false,
             conference: isConference,
         };
-        const options = this.getMediaConfiguration(false, isConference);
-        if (!this._isWeb()) {
+        const options = getMediaConfiguration(false, isConference);
+        if (!isWeb()) {
             // We should sent an empty `sessionDescriptionHandlerModifiers` or sip.js will take the last sent modifiers
             // (eg: holdModifier)
             options.sessionDescriptionHandlerModifiers = [];
@@ -790,105 +753,27 @@ export default class WebRTCClient extends Emitter {
             logger.warn('sdk webrtc re-invite during resume, error', e);
         });
     }
-    // Returns true if a re-INVITE is required
-    async upgradeToVideo(session, constraints, isConference) {
-        const pc = session.sessionDescriptionHandler?.peerConnection;
-        // 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 this.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 = session.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);
-        }
-        this.setLocalMediaStream(this.getSipSessionId(session), newStream);
-        return newStream;
-    }
-    downgradeToAudio(session) {
-        // Release local video stream when downgrading to audio
-        const sessionDescriptionHandler = session.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);
-        });
-    }
-    async getStreamFromConstraints(constraints, conference = false) {
-        const video = constraints && constraints.video;
-        const { constraints: newConstraints, } = this.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;
-    }
     getHeldSession(sessionId) {
         return this.heldSessions[sessionId];
     }
     isCallHeld(session) {
-        return this.getSipSessionId(session) in this.heldSessions;
+        return getSipSessionId(session) in this.heldSessions;
     }
     isVideoRemotelyHeld(sessionId) {
-        const pc = this.getPeerConnection(sessionId);
-        const sdp = pc && pc.remoteDescription ? pc.remoteDescription.sdp : null;
-        if (!sdp) {
-            return false;
-        }
-        const videoDirection = getVideoDirection(sdp);
-        return videoDirection === 'sendonly';
+        return isVideoRemotelyHeld(this.heldSessions[sessionId]);
     }
     sendDTMF(session, tone) {
         if (!session.sessionDescriptionHandler) {
             return false;
         }
         logger.info('Sending DTMF', {
-            id: this.getSipSessionId(session),
+            id: getSipSessionId(session),
             tone,
         });
         return session.sessionDescriptionHandler.sendDtmf(tone);
     }
     message(destination, message) {
-        const uri = this._makeURI(destination);
+        const uri = makeURI(destination, this.config.host);
         if (!this.userAgent || !uri) {
             logger.warn('Null value on message', { uri, userAgent: this.userAgent });
             return;
@@ -899,7 +784,7 @@ export default class WebRTCClient extends Emitter {
     transfer(session, target) {
         this.hold(session);
         logger.info('Transfering a session', {
-            id: this.getSipSessionId(session),
+            id: getSipSessionId(session),
             target,
         });
         const options = {
@@ -910,7 +795,7 @@ export default class WebRTCClient extends Emitter {
             },
         };
         setTimeout(() => {
-            const uri = this._makeURI(target);
+            const uri = makeURI(target, this.config.host);
             if (!uri) {
                 logger.warn('transfer timeout: null URI');
                 return;
@@ -922,21 +807,21 @@ export default class WebRTCClient extends Emitter {
     atxfer(session) {
         this.hold(session);
         logger.info('webrtc transfer started', {
-            id: this.getSipSessionId(session),
+            id: getSipSessionId(session),
         });
         const result = {
             newSession: null,
             init: async (target) => {
                 logger.info('webrtc transfer initialized', {
-                    id: this.getSipSessionId(session),
+                    id: getSipSessionId(session),
                     target,
                 });
                 result.newSession = await this.call(target);
             },
             complete: () => {
                 logger.info('webrtc transfer completed', {
-                    id: this.getSipSessionId(session),
-                    referId: this.getSipSessionId(result.newSession),
+                    id: getSipSessionId(session),
+                    referId: getSipSessionId(result.newSession),
                 });
                 session.refer(result.newSession);
             },
@@ -977,7 +862,7 @@ export default class WebRTCClient extends Emitter {
             return;
         }
         const core = this.userAgent?.userAgentCore;
-        const fromURI = this._makeURI(this.config.authorizationUser || '');
+        const fromURI = makeURI(this.config.authorizationUser || '', this.config.host);
         const toURI = new URI('sip', '', this.config.host);
         if (fromURI) {
             const message = core?.makeOutgoingRequestMessage('OPTIONS', toURI, fromURI, toURI, {});
@@ -995,9 +880,6 @@ export default class WebRTCClient extends Emitter {
     getContactIdentifier() {
         return this.userAgent ? `${this.userAgent.configuration.contactName}/${this.userAgent.contact.uri}` : null;
     }
-    isFirefox() {
-        return this._isWeb() && navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
-    }
     changeAudioOutputVolume(volume) {
         logger.info('Changing audio output volume', {
             volume,
@@ -1101,12 +983,12 @@ export default class WebRTCClient extends Emitter {
         };
     }
     changeSessionVideoInputDevice(id, session) {
-        if (!this.sessionWantsToDoVideo(session)) {
+        if (!sessionWantsToDoVideo(session)) {
             return Promise.resolve();
         }
         const sdh = session.sessionDescriptionHandler;
         const pc = sdh.peerConnection;
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         const localStream = this.getLocalStream(sessionId);
         logger.info('changing video input device', {
             id,
@@ -1143,7 +1025,7 @@ export default class WebRTCClient extends Emitter {
             }
             // let's update the local stream
             this.eventEmitter.emit('onVideoInputChange', stream);
-            this.setLocalMediaStream(sessionId, stream);
+            setLocalMediaStream(this.sipSessions[sessionId], stream);
             return stream;
         });
     }
@@ -1162,12 +1044,12 @@ export default class WebRTCClient extends Emitter {
             return Promise.resolve();
         }
         const wasMuted = this.isAudioMuted(sipSession);
-        const shouldDoVideo = newConstraints ? newConstraints.video : this.sessionWantsToDoVideo(sipSession);
+        const shouldDoVideo = newConstraints ? newConstraints.video : sessionWantsToDoVideo(sipSession);
         const shouldDoScreenSharing = newConstraints && newConstraints.screen;
         const desktop = newConstraints && newConstraints.desktop;
         logger.info('Sending reinvite', {
             clientId: this.clientId,
-            id: this.getSipSessionId(sipSession),
+            id: getSipSessionId(sipSession),
             newConstraints,
             conference,
             audioOnly,
@@ -1185,7 +1067,7 @@ export default class WebRTCClient extends Emitter {
             conference,
             audioOnly,
         };
-        const { constraints, } = this.getMediaConfiguration(shouldDoVideo, conference, newConstraints);
+        const { constraints, } = getMediaConfiguration(shouldDoVideo, conference, newConstraints);
         return sipSession.invite({
             requestDelegate: {
                 onAccept: (response) => {
@@ -1201,11 +1083,11 @@ export default class WebRTCClient extends Emitter {
                         sipSession.incomingInviteRequest.message.body = response.message.body;
                     }
                     logger.info('on re-INVITE accepted', {
-                        id: this.getSipSessionId(sipSession),
+                        id: getSipSessionId(sipSession),
                         wasMuted,
                         shouldDoScreenSharing,
                     });
-                    this.updateRemoteStream(this.getSipSessionId(sipSession), false);
+                    updateRemoteStream(sipSession, false);
                     if (wasMuted) {
                         this.mute(sipSession);
                     }
@@ -1238,103 +1120,55 @@ export default class WebRTCClient extends Emitter {
         return navigator.mediaDevices.getUserMedia(newConstraints);
     }
     getPeerConnection(sessionId) {
-        const sipSession = this.sipSessions[sessionId];
-        if (!sipSession) {
-            return null;
-        }
-        return sipSession.sessionDescriptionHandler ? sipSession.sessionDescriptionHandler.peerConnection : null;
+        return getPeerConnection(this.sipSessions[sessionId]);
     }
     // Local streams
     getLocalStream(sessionId) {
-        const sipSession = this.sipSessions[sessionId];
-        return sipSession?.sessionDescriptionHandler?.localMediaStream || null;
+        return getLocalStream(this.sipSessions[sessionId]);
     }
     getLocalTracks(sessionId) {
-        const localStream = this.getLocalStream(sessionId);
-        if (!localStream) {
-            return [];
-        }
-        return localStream.getTracks();
+        return getLocalTracks(this.sipSessions[sessionId]);
     }
     hasLocalVideo(sessionId) {
-        return this.getLocalTracks(sessionId).some(this._isVideoTrack);
+        return hasLocalVideo(this.sipSessions[sessionId]);
     }
     // Check if we have at least one video track, even muted or not live
     hasALocalVideoTrack(sessionId) {
-        return this.getLocalTracks(sessionId).some(track => track.kind === 'video');
+        return hasALocalVideoTrack(this.sipSessions[sessionId]);
     }
     getLocalVideoStream(sessionId) {
-        return this.hasLocalVideo(sessionId) ? this.getLocalStream(sessionId) : null;
+        return getLocalVideoStream(this.sipSessions[sessionId]);
     }
     // Remote streams
     getRemoteStream(sessionId) {
-        const sipSession = this.sipSessions[sessionId];
-        return sipSession?.sessionDescriptionHandler?.remoteMediaStream || null;
+        return getRemoteStream(this.sipSessions[sessionId]);
     }
     getRemoteTracks(sessionId) {
-        const remoteStream = this.getRemoteStream(sessionId);
-        if (!remoteStream) {
-            return [];
-        }
-        return remoteStream.getTracks();
+        return getRemoteTracks(this.sipSessions[sessionId]);
     }
     hasRemoteVideo(sessionId) {
-        return this.getRemoteTracks(sessionId).some(this._isVideoTrack);
+        return hasRemoteVideo(this.sipSessions[sessionId]);
     }
     // Check if we have at least one video track, even muted or not live
     hasARemoteVideoTrack(sessionId) {
-        return this.getRemoteTracks(sessionId).some(track => track.kind === 'video');
+        return hasARemoteVideoTrack(this.sipSessions[sessionId]);
     }
     getRemoteVideoStream(sessionId) {
-        if (this.isVideoRemotelyHeld(sessionId)) {
-            return null;
-        }
-        return this.hasRemoteVideo(sessionId) ? this.getRemoteStream(sessionId) : null;
+        return getRemoteVideoStream(this.sipSessions[sessionId]);
     }
     //  Useful in a react-native environment when remoteMediaStream is not updated
     getRemoteVideoStreamFromPc(sessionId) {
-        const pc = this.getPeerConnection(sessionId);
-        if (!pc) {
-            return null;
-        }
-        return pc.getRemoteStreams().find((stream) => !!stream.getVideoTracks().length);
+        return getRemoteVideoStreamFromPc(this.sipSessions[sessionId]);
     }
     hasVideo(sessionId) {
-        return this.hasLocalVideo(sessionId) || this.hasRemoteVideo(sessionId);
+        return hasVideoTrack(this.sipSessions[sessionId]);
     }
     hasAVideoTrack(sessionId) {
-        return this.hasALocalVideoTrack(sessionId) || this.hasARemoteVideoTrack(sessionId);
-    }
-    getSipSessionId(sipSession) {
-        if (!sipSession) {
-            return '';
-        }
-        const message = sipSession.message;
-        if (message?.callId) {
-            return message.callId.substring(0, SIP_ID_LENGTH);
-        }
-        // For Inviter
-        // @ts-ignore: private
-        if (sipSession instanceof Inviter && sipSession.outgoingRequestMessage) {
-            // @ts-ignore: private
-            return sipSession.outgoingRequestMessage.callId.substring(0, SIP_ID_LENGTH);
-        }
-        // For Invitation
-        return (sipSession.id || '').substring(0, SIP_ID_LENGTH);
+        return hasAVideoTrack(this.sipSessions[sessionId]);
     }
     async waitForRegister() {
         return new Promise(resolve => this.on(REGISTERED, resolve));
     }
-    // eslint-disable-next-line no-unused-vars
-    sessionWantsToDoVideo(session) {
-        if (!session) {
-            return false;
-        }
-        const { body, } = session.request || session;
-        // Sometimes with InviteClientContext the body is in the body attribute ...
-        const sdp = typeof body === 'object' && body ? body.body : body;
-        return hasAnActiveVideo(sdp);
-    }
     hasHeartbeat() {
         return this.heartbeat.hasHeartbeat;
     }
@@ -1360,7 +1194,7 @@ export default class WebRTCClient extends Emitter {
     }
     onCallEnded(session) {
         this._cleanupMedia(session);
-        delete this.sipSessions[this.getSipSessionId(session)];
+        delete this.sipSessions[getSipSessionId(session)];
         this._stopSendingStats(session);
         this.stopNetworkMonitoring(session);
     }
@@ -1373,7 +1207,7 @@ export default class WebRTCClient extends Emitter {
         this.userAgent.attemptReconnection();
     }
     storeSipSession(session) {
-        const id = this.getSipSessionId(session);
+        const id = getSipSessionId(session);
         logger.info('storing sip session', { id, clientId: this.clientId });
         this.sipSessions[id] = session;
     }
@@ -1383,21 +1217,6 @@ export default class WebRTCClient extends Emitter {
     getSipSessionIds() {
         return Object.keys(this.sipSessions);
     }
-    setLocalMediaStream(sipSessionId, newStream) {
-        const sipSession = this.sipSessions[sipSessionId];
-        if (!sipSession) {
-            return;
-        }
-        logger.info('setting local media stream', {
-            sipSessionId,
-            tracks: newStream ? newStream.getTracks() : null,
-        });
-        if (sipSession.sessionDescriptionHandler) {
-            // eslint-disable-next-line no-underscore-dangle
-            // @ts-ignore: protected
-            sipSession.sessionDescriptionHandler._localMediaStream = newStream;
-        }
-    }
     async updateLocalStream(sipSessionId, newStream) {
         const sipSession = this.sipSessions[sipSessionId];
         if (!sipSession) {
@@ -1410,76 +1229,12 @@ export default class WebRTCClient extends Emitter {
             tracks: newStream.getTracks(),
         });
         if (oldStream) {
-            this._cleanupStream(oldStream);
+            cleanupStream(oldStream);
         }
-        this.setLocalMediaStream(sipSessionId, newStream);
+        setLocalMediaStream(sipSession, newStream);
         // Update the local video element
         await this._setupMedias(sipSession, newStream);
     }
-    updateRemoteStream(sessionId, allTracks = true) {
-        const remoteStream = this.getRemoteStream(sessionId);
-        const pc = this.getPeerConnection(sessionId);
-        logger.info('Updating remote stream', {
-            sessionId,
-            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);
-                }
-            });
-        }
-    }
-    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 : withAudio ? this._getAudioConstraints() : false,
-                video: screenSharing ? isDesktop ? {
-                    mandatory: {
-                        chromeMediaSource: 'desktop',
-                        ...(mandatoryVideo || {}),
-                    },
-                } : {
-                    cursor: 'always',
-                } : this._getVideoConstraints(enableVideo),
-                screen: screenSharing,
-                desktop: isDesktop,
-                conference,
-            },
-            enableVideo,
-            conference,
-            offerOptions: {
-                OfferToReceiveAudio: this._hasAudio(),
-                OfferToReceiveVideo: enableVideo,
-                mandatory: {
-                    OfferToReceiveAudio: this._hasAudio(),
-                    OfferToReceiveVideo: enableVideo,
-                },
-            },
-        };
-    }
     isConference(sessionId) {
         return sessionId in this.conferences;
     }
@@ -1555,25 +1310,14 @@ export default class WebRTCClient extends Emitter {
             this._onTransportError();
         }
     }
-    _isWeb() {
-        return typeof window === 'object' && typeof document === 'object';
-    }
-    _isVideoTrack(track) {
-        return track.kind === 'video' && track.readyState === 'live';
-    }
     _hasAudio() {
         return this.hasAudio;
     }
     _getAudioConstraints() {
-        // @ts-ignore: media constraints
-        return this.audio?.deviceId?.exact ? this.audio : true;
+        return getAudioConstraints(this.audio);
     }
     _getVideoConstraints(video = false) {
-        if (!video) {
-            return false;
-        }
-        // @ts-ignore: media constraints
-        return this.video?.deviceId?.exact ? this.video : true;
+        return getVideoConstraints(video && this.video);
     }
     _connectIfNeeded() {
         logger.info('connect if needed, checking', { connected: this.isConnected(), clientId: this.clientId });
@@ -1623,97 +1367,16 @@ export default class WebRTCClient extends Emitter {
             ...config,
         }));
     }
-    _createUaOptions(uaOptionsOverrides = {}) {
-        let { host, } = this.config;
-        let port = this.config.port || 443;
-        if (this.config.websocketSip) {
-            const webSocketSip = this.config.websocketSip.split(':');
-            [host] = webSocketSip;
-            port = Number(webSocketSip[1]);
-        }
-        const { userUuid } = this.config;
-        const uaOptions = {
-            noAnswerTimeout: NO_ANSWER_TIMEOUT,
-            authorizationUsername: this.config.authorizationUser,
-            authorizationPassword: this.config.password,
-            displayName: this.config.displayName,
-            hackIpInContact: true,
-            contactParams: {
-                transport: 'wss',
-            },
-            logBuiltinEnabled: this.config.log ? this.config.log.builtinEnabled : null,
-            logLevel: this.config.log ? this.config.log.logLevel : null,
-            logConnector: this.config.log ? this.config.log.connector : null,
-            uri: this._makeURI(this.config.authorizationUser || ''),
-            userAgentString: this.config.userAgentString || 'wazo-sdk',
-            reconnectionAttempts: 10000,
-            reconnectionDelay: 5,
-            sessionDescriptionHandlerFactory: (session, options = {}) => {
-                const uaLogger = session.userAgent.getLogger('sip.WazoSessionDescriptionHandler');
-                const isWeb = this._isWeb();
-                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, session);
-            },
-            transportOptions: {
-                traceSip: uaOptionsOverrides?.traceSip || false,
-                wsServers: `wss://${host}:${port}/api/asterisk/ws${userUuid ? `?userUuid=${userUuid}` : ''}`,
-            },
-            sessionDescriptionHandlerFactoryOptions: {
-                modifiers: [replaceLocalIpModifier],
-                alwaysAcquireMediaFirst: this.isFirefox(),
-                constraints: {
-                    audio: this._getAudioConstraints(),
-                    video: this._getVideoConstraints(),
-                },
-                peerConnectionOptions: {
-                    iceCheckingTimeout: this.config.iceCheckingTimeout || 1000,
-                    iceGatheringTimeout: this.config.iceCheckingTimeout || 1000,
-                    rtcConfiguration: {
-                        rtcpMuxPolicy: 'require',
-                        iceServers: WebRTCClient.getIceServers(this.config.host),
-                        ...this._getRtcOptions(),
-                        ...(uaOptionsOverrides?.peerConnectionOptions || {}),
-                    },
-                },
-                // Configuration used in SDH to create the PeerConnection
-                peerConnectionConfiguration: {
-                    rtcpMuxPolicy: 'require',
-                    iceServers: WebRTCClient.getIceServers(this.config.host),
-                    ...(uaOptionsOverrides?.peerConnectionOptions || {}),
-                },
-            },
-        };
-        delete uaOptionsOverrides?.traceSip;
-        return {
-            ...uaOptions,
-            ...uaOptionsOverrides,
-        };
-    }
-    // eslint-disable-next-line no-unused-vars
-    _getRtcOptions() {
-        return {
-            mandatory: {
-                OfferToReceiveAudio: this._hasAudio(),
-                OfferToReceiveVideo: false,
-            },
-        };
-    }
     // Invitation and Inviter extends Session
     _setupSession(session) {
-        const sipSessionId = this.getSipSessionId(session);
+        const sipSessionId = getSipSessionId(session);
         // When receiving an Invitation, the delegate is not defined.
         if (!session.delegate) {
             session.delegate = {};
         }
         session.delegate.onSessionDescriptionHandler = (sdh) => {
             sdh.on('error', (e) => {
-                this.eventEmitter.emit(ON_ERROR, e);
+                this.eventEmitter.emit(ON_ERROR, e, session);
             });
             sdh.peerConnectionDelegate = {
                 onicecandidateerror: (error) => {
@@ -1762,15 +1425,15 @@ export default class WebRTCClient extends Emitter {
                 // @ts-ignore: private
                 session.outgoingInviteRequest.message.body.body = request.body;
             }
-            this.updateRemoteStream(sipSessionId, false);
+            updateRemoteStream(this.sipSessions[sipSessionId], false);
             await this._setupMedias(session);
             return this.eventEmitter.emit(ON_REINVITE, session, request, updatedCalleeName, updatedNumber, hadRemoteVideo);
         };
     }
     async _onProgress(session, early = false) {
         await this._setupMedias(session);
-        const sessionId = this.getSipSessionId(session).substr(0, 20);
-        this.updateRemoteStream(sessionId);
+        const sessionId = getSipSessionId(session).substr(0, 20);
+        updateRemoteStream(session);
         logger.info('progress received', {
             sessionId,
             early,
@@ -1785,21 +1448,14 @@ export default class WebRTCClient extends Emitter {
         });
         this.storeSipSession(session);
         await this._setupMedias(session);
-        this.updateRemoteStream(this.getSipSessionId(session), initAllTracks);
-        const pc = session.sessionDescriptionHandler?.peerConnection;
+        updateRemoteStream(session, initAllTracks);
+        const pc = getPeerConnection(session);
         const onTrack = (event) => {
-            const isAudioOnly = this._isAudioOnly(session);
-            const { kind, label, readyState, id, muted, } = event.track;
-            logger.info('on track event', {
-                isAudioOnly,
-                kind,
-                label,
-                readyState,
-                id,
-                muted,
-            });
+            const audioOnly = isAudioOnly(session);
+            const { kind, label, readyState, id, muted } = event.track;
+            logger.info('on track event', { audioOnly, kind, label, readyState, id, muted });
             // Stop video track in audio only mode
-            if (isAudioOnly && kind === 'video') {
+            if (audioOnly && kind === 'video') {
                 event.track.stop();
             }
             this.eventEmitter.emit(ON_TRACK, session, event);
@@ -1824,16 +1480,13 @@ export default class WebRTCClient extends Emitter {
         }
         this._startSendingStats(session);
     }
-    _isAudioOnly(session) {
-        return Boolean(session.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === stripVideo));
-    }
     async _setupMedias(session, newStream = null) {
-        if (!this._isWeb()) {
+        if (!isWeb()) {
             logger.info('Setup media on mobile, no need to setup html element, bailing');
             return;
         }
         // Safari hack, because you cannot call .play() from a non user action
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         const isConference = this.isConference(sessionId);
         if (sessionId in this.audioElements) {
             logger.info('html element already exists for session', {
@@ -1841,7 +1494,7 @@ export default class WebRTCClient extends Emitter {
             });
             return;
         }
-        if (this._hasAudio() && this._isWeb() && !(sessionId in this.audioElements)) {
+        if (this._hasAudio() && isWeb() && !(sessionId in this.audioElements)) {
             await this.createAudioElementFor(sessionId);
         }
         const audioElement = this.audioElements[sessionId];
@@ -1878,10 +1531,10 @@ export default class WebRTCClient extends Emitter {
         audioElement.play().catch(() => { });
     }
     _cleanupMedia(session) {
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         const localStream = this.getLocalStream(sessionId);
         if (localStream) {
-            this._cleanupStream(localStream);
+            cleanupStream(localStream);
         }
         const cleanLocalElement = (id) => {
             const element = this.audioElements[id];
@@ -1895,80 +1548,15 @@ export default class WebRTCClient extends Emitter {
             element.srcObject = null;
             delete this.audioElements[id];
         };
-        if (this._hasAudio() && this._isWeb()) {
+        if (this._hasAudio() && isWeb()) {
             if (session) {
-                cleanLocalElement(this.getSipSessionId(session));
+                cleanLocalElement(getSipSessionId(session));
             }
             else {
                 Object.keys(this.audioElements).forEach(id => cleanLocalElement(id));
             }
         }
     }
-    _cleanupStream(stream) {
-        stream.getTracks().filter(track => track.enabled).forEach(track => track.stop());
-    }
-    _toggleAudio(session, muteAudio) {
-        const sdh = session.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;
-                });
-            });
-        }
-    }
-    _toggleVideo(session, muteCamera) {
-        const sdh = session.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;
-                });
-            });
-        }
-    }
-    /**
-     * @param pc RTCPeerConnection
-     */
-    _getRemoteStream(pc) {
-        let remoteStream = null;
-        if (pc && pc.getReceivers) {
-            remoteStream = typeof global !== 'undefined' && global.window && global.window.MediaStream ? new global.window.MediaStream() : new window.MediaStream();
-            pc.getReceivers().forEach((receiver) => {
-                const { track, } = receiver;
-                if (track && remoteStream) {
-                    remoteStream.addTrack(track);
-                }
-            });
-        }
-        else if (pc) {
-            [remoteStream] = pc.getRemoteStreams();
-        }
-        return remoteStream;
-    }
     _cleanupRegister() {
         if (this.registerer) {
             // @ts-ignore: removeAllListeners does not exist
@@ -1982,7 +1570,7 @@ export default class WebRTCClient extends Emitter {
         if (!pc) {
             return;
         }
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         getStats(pc, (result) => {
             const { results, internal, nomore, ...stats } = result;
             this.statsIntervals[sessionId] = nomore;
@@ -1993,7 +1581,7 @@ export default class WebRTCClient extends Emitter {
         }, SEND_STATS_DELAY);
     }
     _stopSendingStats(session) {
-        const sessionId = this.getSipSessionId(session);
+        const sessionId = getSipSessionId(session);
         logger.trace('Check for stopping stats', {
             sessionId,
             ids: Object.keys(this.statsIntervals),
@@ -2006,9 +1594,6 @@ export default class WebRTCClient extends Emitter {
             delete this.statsIntervals[sessionId];
         }
     }
-    _makeURI(target) {
-        return UserAgent.makeURI(`sip:${target}@${this.config.host}`);
-    }
     async _disconnectTransport(force = false) {
         const transport = this.userAgent?.transport;
         if (force && transport) {
@@ -2030,96 +1615,13 @@ export default class WebRTCClient extends Emitter {
         }
     }
     async _fetchNetworkStats(sessionId) {
-        const session = this.getSipSession(sessionId);
-        const stats = session ? await this.getStats(session) : null;
-        if (!stats || !(sessionId in this.sessionNetworkStats)) {
+        const session = this.sipSessions[sessionId];
+        if (!(sessionId in this.sessionNetworkStats)) {
             return Promise.resolve(null);
         }
-        const networkStats = {
-            audioBytesSent: 0,
-            videoBytesSent: 0,
-            videoBytesReceived: 0,
-            audioBytesReceived: 0,
-        };
         const nbStats = this.sessionNetworkStats[sessionId].length;
         const lastNetworkStats = this.sessionNetworkStats[sessionId][nbStats - 1];
-        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;
+        const networkStats = await fetchNetworkStats(session, lastNetworkStats);
         if (this.sessionNetworkStats[sessionId]) {
             this.eventEmitter.emit(ON_NETWORK_STATS, session, networkStats, this.sessionNetworkStats[sessionId]);
             if (sessionId in this.sessionNetworkStats) {