@wazo/sdk 0.43.6 → 1.0.0-alpha.0

package/src/web-rtc-client.ts

@@ -1,6 +1,6 @@
 /* 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 type { InviterInviteOptions } from 'sip.js/lib/api/inviter-invite-options';
 import type { InvitationRejectOptions } from 'sip.js/lib/api/invitation-reject-options';
@@ -9,8 +9,6 @@ import type { SessionByeOptions } from 'sip.js/lib/api/session-bye-options';
 import type { InvitationAcceptOptions } from 'sip.js/lib/api/invitation-accept-options';
 import type { SessionDialog } from 'sip.js/lib/core/dialogs/session-dialog';
 import type { IncomingRequestMessage } from 'sip.js/lib/core/messages/incoming-request-message';
-import type { SessionDescriptionHandlerFactoryOptions } from 'sip.js/lib/platform/web/session-description-handler/session-description-handler-factory-options';
-import type { SessionDescriptionHandlerConfiguration } from 'sip.js/lib/platform/web/session-description-handler/session-description-handler-configuration';
 import type { SessionDescriptionHandler } from 'sip.js/lib/platform/web/session-description-handler/session-description-handler';
 import { UserAgentState } from 'sip.js/lib/api/user-agent-state';
 import { Parser } from 'sip.js/lib/core/messages/parser';
@@ -23,27 +21,18 @@ 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 { OutgoingByeRequest, OutgoingInviteRequest, OutgoingRequest } from 'sip.js/lib/core';
-import { Inviter, Invitation, Registerer, Session, SessionDescriptionHandlerOptions } from 'sip.js/lib/api';
-import WazoSessionDescriptionHandler, { wazoMediaStreamFactory } from './lib/WazoSessionDescriptionHandler';
+import { Inviter, Invitation, Registerer, SessionDescriptionHandlerOptions } from 'sip.js/lib/api';
 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';
-import type { MediaConfig, UserAgentConfigOverrides, WebRtcConfig, UserAgentOptions, IncomingResponse, PeerConnection, WazoSession, WazoTransport } from './domain/types';
-
-// 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: Record<string, any>) => Promise.resolve({ // description is immutable... so we have to clone it or the `type` attribute won't be returned.
-  ...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 type { MediaConfig, UserAgentConfigOverrides, WebRtcConfig, IncomingResponse, PeerConnection, WazoSession, WazoTransport } from './domain/types';
+import { cleanupStream, createUaOptions, fetchNetworkStats, getAudioConstraints, getLocalStream, getLocalTracks, getLocalVideoStream, getMediaConfiguration, getPeerConnection, getRemoteStream, getRemoteTracks, getRemoteVideoStream, getRemoteVideoStreamFromPc, getStreamFromConstraints, 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;
@@ -67,13 +56,12 @@ const ON_ERROR = 'onError';
 const ON_SCREEN_SHARING_REINVITE = 'onScreenSharingReinvite';
 const ON_NETWORK_STATS = 'onNetworkStats';
 const ON_DISCONNECTED = 'onDisconnected';
+
 export const events = [REGISTERED, UNREGISTERED, REGISTRATION_FAILED, INVITE];
 export const transportEvents = [CONNECTED, DISCONNECTED, TRANSPORT_ERROR, MESSAGE];
 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: number;
@@ -165,23 +153,6 @@ export default class WebRTCClient extends Emitter {
 
   ON_DISCONNECTED: string;
 
-  static isAPrivateIp(ip: string): boolean {
-    const regex = /^(?:10|127|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168)\..*/;
-    return regex.exec(ip) == null;
-  }
-
-  static getIceServers(ip: string): Array<{
-    urls: Array<string>;
-  }> {
-    if (WebRTCClient.isAPrivateIp(ip)) {
-      return [{
-        urls: ['stun:stun.l.google.com:19302', 'stun:stun4.l.google.com:19302'],
-      }];
-    }
-
-    return [];
-  }
-
   constructor(config: WebRtcConfig, session?: WazoSession, uaConfigOverrides?: UserAgentConfigOverrides) {
     super();
 
@@ -254,7 +225,7 @@ export default class WebRTCClient extends Emitter {
   }
 
   createUserAgent(uaConfigOverrides?: UserAgentConfigOverrides): UserAgent {
-    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` },
@@ -275,7 +246,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);
@@ -386,7 +357,7 @@ export default class WebRTCClient extends Emitter {
       return Promise.resolve();
     }
 
-    const registerOptions = this._isWeb() ? {} : {
+    const registerOptions = isWeb() ? {} : {
       extraContactHeaderParams: ['mobility=mobile'],
     };
 
@@ -572,7 +543,7 @@ export default class WebRTCClient extends Emitter {
       inviterOptions.sessionDescriptionHandlerModifiersReInvite = [stripVideo];
     }
 
-    const uri = this._makeURI(number);
+    const uri = makeURI(number, this.config.host);
     let session: WazoSession | null = null;
 
     if (uri) {
@@ -588,7 +559,7 @@ export default class WebRTCClient extends Emitter {
     }
 
     if (conference) {
-      this.conferences[this.getSipSessionId(session)] = true;
+      this.conferences[getSipSessionId(session)] = true;
     }
 
     const inviteOptions: InviterInviteOptions = {
@@ -615,7 +586,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) {
@@ -652,7 +623,7 @@ export default class WebRTCClient extends Emitter {
     }
 
     const options = {
-      sessionDescriptionHandlerOptions: this.getMediaConfiguration(enableVideo || false),
+      sessionDescriptionHandlerOptions: getMediaConfiguration(enableVideo || false),
     };
     return this._accept(session, options).then(() => {
       // @ts-ignore: private
@@ -683,7 +654,7 @@ export default class WebRTCClient extends Emitter {
 
       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;
 
@@ -707,19 +678,9 @@ export default class WebRTCClient extends Emitter {
     return Promise.resolve(null);
   }
 
-  async getStats(session: WazoSession): Promise<RTCStatsReport | null> {
-    const pc = (session.sessionDescriptionHandler as SessionDescriptionHandler)?.peerConnection as RTCPeerConnection;
-
-    if (!pc) {
-      return null;
-    }
-
-    return pc.getStats(null);
-  }
-
   // Fetch and emit an event at `interval` with session network stats
   startNetworkMonitoring(session: WazoSession, interval = 1000): void {
-    const sessionId = this.getSipSessionId(session);
+    const sessionId = getSipSessionId(session);
     logger.info('starting network inspection', {
       id: sessionId,
       clientId: this.clientId,
@@ -729,7 +690,7 @@ export default class WebRTCClient extends Emitter {
   }
 
   stopNetworkMonitoring(session: WazoSession): void {
-    const sessionId = this.getSipSessionId(session);
+    const sessionId = getSipSessionId(session);
     const exists = (sessionId in this.networkMonitoringInterval);
     logger.info('stopping network inspection', {
       clientId: this.clientId,
@@ -808,21 +769,12 @@ export default class WebRTCClient extends Emitter {
     logger.info('sdk webrtc client closed', { clientId: this.clientId });
   }
 
-  getNumber(session: Inviter): string | null | undefined {
-    if (!session) {
-      return null;
-    }
-
-    // @ts-ignore: private
-    return session.remoteIdentity.uri._normal.user;
-  }
-
   mute(session: WazoSession): void {
     logger.info('sdk webrtc mute', {
       id: session.id,
     });
 
-    this._toggleAudio(session, true);
+    toggleAudio(session, true);
   }
 
   unmute(session: WazoSession): void {
@@ -830,7 +782,7 @@ export default class WebRTCClient extends Emitter {
       id: session.id,
     });
 
-    this._toggleAudio(session, false);
+    toggleAudio(session, false);
   }
 
   isAudioMuted(session: WazoSession): boolean {
@@ -875,7 +827,7 @@ export default class WebRTCClient extends Emitter {
       id: session.id,
     });
 
-    this._toggleVideo(session, false);
+    toggleVideo(session, false);
   }
 
   toggleCameraOff(session: WazoSession): void {
@@ -883,11 +835,11 @@ export default class WebRTCClient extends Emitter {
       id: session.id,
     });
 
-    this._toggleVideo(session, true);
+    toggleVideo(session, true);
   }
 
   hold(session: WazoSession, isConference = false, hadVideo = false): Promise<OutgoingInviteRequest | void> {
-    const sessionId = this.getSipSessionId(session);
+    const sessionId = getSipSessionId(session);
     const hasVideo = hadVideo || this.hasLocalVideo(sessionId);
     logger.info('sdk webrtc hold', {
       sessionId,
@@ -920,9 +872,9 @@ export default class WebRTCClient extends Emitter {
       hold: true,
       conference: isConference,
     } as SessionDescriptionHandlerOptions;
-    const options = this.getMediaConfiguration(false, isConference);
+    const options = getMediaConfiguration(false, isConference);
 
-    if (!this._isWeb()) {
+    if (!isWeb()) {
       options.sessionDescriptionHandlerModifiers = [holdModifier];
     }
 
@@ -945,7 +897,7 @@ export default class WebRTCClient extends Emitter {
   }
 
   unhold(session: WazoSession, isConference = false): Promise<OutgoingInviteRequest | void> {
-    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,
@@ -963,14 +915,14 @@ export default class WebRTCClient extends Emitter {
 
     this.unmute(session);
 
-    delete this.heldSessions[this.getSipSessionId(session)];
+    delete this.heldSessions[getSipSessionId(session)];
     session.sessionDescriptionHandlerOptionsReInvite = {
       hold: false,
       conference: isConference,
     } as SessionDescriptionHandlerOptions;
-    const options = this.getMediaConfiguration(false, isConference);
+    const options = getMediaConfiguration(false, isConference);
 
-    if (!this._isWeb()) {
+    if (!isWeb()) {
       // We should sent an empty `sessionDescriptionHandlerModifiers` or sip.js will take the last sent modifiers
       // (eg: holdModifier)
       options.sessionDescriptionHandlerModifiers = [];
@@ -987,113 +939,16 @@ export default class WebRTCClient extends Emitter {
     });
   }
 
-  // Returns true if a re-INVITE is required
-  async upgradeToVideo(session: WazoSession, constraints: Record<string, any>, isConference: boolean): Promise<MediaStream | undefined> {
-    const pc = (session.sessionDescriptionHandler as 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: MediaStream = (session.sessionDescriptionHandler as 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: WazoSession): void {
-    // Release local video stream when downgrading to audio
-    const sessionDescriptionHandler = session.sessionDescriptionHandler as 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: MediaStreamTrack) => {
-      videoTrack.enabled = false;
-      videoTrack.stop();
-      localStream.removeTrack(videoTrack);
-    });
-  }
-
-  async getStreamFromConstraints(constraints: Record<string, any>, conference = false): Promise<MediaStream | null | undefined> {
-    const video = constraints && constraints.video;
-    const {
-      constraints: newConstraints,
-    } = this.getMediaConfiguration(video, conference, constraints);
-    let newStream: MediaStream & { local?: boolean } | null = null;
-
-    try {
-      newStream = await wazoMediaStreamFactory(newConstraints);
-    } catch (e: any) { // Nothing to do when the user cancel the screensharing prompt
-    }
-
-    if (!newStream) {
-      return null;
-    }
-
-    newStream.local = true;
-    return newStream;
-  }
-
   getHeldSession(sessionId: string) {
     return this.heldSessions[sessionId];
   }
 
   isCallHeld(session: WazoSession): boolean {
-    return this.getSipSessionId(session) in this.heldSessions;
+    return getSipSessionId(session) in this.heldSessions;
   }
 
   isVideoRemotelyHeld(sessionId: string): boolean {
-    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: WazoSession, tone: string): boolean {
@@ -1102,14 +957,14 @@ export default class WebRTCClient extends Emitter {
     }
 
     logger.info('Sending DTMF', {
-      id: this.getSipSessionId(session),
+      id: getSipSessionId(session),
       tone,
     });
     return session.sessionDescriptionHandler.sendDtmf(tone);
   }
 
   message(destination: string, message: string): void {
-    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;
@@ -1121,7 +976,7 @@ export default class WebRTCClient extends Emitter {
   transfer(session: WazoSession, target: string): void {
     this.hold(session);
     logger.info('Transfering a session', {
-      id: this.getSipSessionId(session),
+      id: getSipSessionId(session),
       target,
     });
     const options = {
@@ -1132,7 +987,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;
@@ -1145,21 +1000,21 @@ export default class WebRTCClient extends Emitter {
   atxfer(session: WazoSession): Record<string, any> {
     this.hold(session);
     logger.info('webrtc transfer started', {
-      id: this.getSipSessionId(session),
+      id: getSipSessionId(session),
     });
     const result: Record<string, any> = {
       newSession: null,
       init: async (target: string) => {
         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);
       },
@@ -1205,7 +1060,7 @@ export default class WebRTCClient extends Emitter {
 
     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) {
@@ -1229,10 +1084,6 @@ export default class WebRTCClient extends Emitter {
     return this.userAgent ? `${this.userAgent.configuration.contactName}/${this.userAgent.contact.uri}` : null;
   }
 
-  isFirefox(): boolean {
-    return this._isWeb() && navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
-  }
-
   changeAudioOutputVolume(volume: number): void {
     logger.info('Changing audio output volume', {
       volume,
@@ -1356,13 +1207,13 @@ export default class WebRTCClient extends Emitter {
   }
 
   changeSessionVideoInputDevice(id: string | null | undefined, session: WazoSession): Promise<MediaStream | void> {
-    if (!this.sessionWantsToDoVideo(session)) {
+    if (!sessionWantsToDoVideo(session)) {
       return Promise.resolve();
     }
 
     const sdh = session.sessionDescriptionHandler as 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,
@@ -1406,7 +1257,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;
     });
   }
@@ -1430,12 +1281,12 @@ export default class WebRTCClient extends Emitter {
     }
 
     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,
@@ -1457,7 +1308,7 @@ export default class WebRTCClient extends Emitter {
     } as SessionDescriptionHandlerOptions;
     const {
       constraints,
-    } = this.getMediaConfiguration(shouldDoVideo, conference, newConstraints);
+    } = getMediaConfiguration(shouldDoVideo, conference, newConstraints);
     return sipSession.invite({
       requestDelegate: {
         onAccept: (response: IncomingResponse) => {
@@ -1473,11 +1324,11 @@ export default class WebRTCClient extends Emitter {
           }
 
           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);
@@ -1516,135 +1367,70 @@ export default class WebRTCClient extends Emitter {
   }
 
   getPeerConnection(sessionId: string) {
-    const sipSession = this.sipSessions[sessionId];
-
-    if (!sipSession) {
-      return null;
-    }
-
-    return sipSession.sessionDescriptionHandler ? (sipSession.sessionDescriptionHandler as SessionDescriptionHandler).peerConnection : null;
+    return getPeerConnection(this.sipSessions[sessionId]);
   }
 
   // Local streams
   getLocalStream(sessionId: string): MediaStream | null {
-    const sipSession = this.sipSessions[sessionId];
-    return (sipSession?.sessionDescriptionHandler as SessionDescriptionHandler)?.localMediaStream || null;
+    return getLocalStream(this.sipSessions[sessionId]);
   }
 
   getLocalTracks(sessionId: string): MediaStreamTrack[] {
-    const localStream = this.getLocalStream(sessionId);
-
-    if (!localStream) {
-      return [];
-    }
-
-    return localStream.getTracks();
+    return getLocalTracks(this.sipSessions[sessionId]);
   }
 
   hasLocalVideo(sessionId: string): boolean {
-    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: string): boolean {
-    return this.getLocalTracks(sessionId).some(track => track.kind === 'video');
+    return hasALocalVideoTrack(this.sipSessions[sessionId]);
   }
 
   getLocalVideoStream(sessionId: string): MediaStream | null | undefined {
-    return this.hasLocalVideo(sessionId) ? this.getLocalStream(sessionId) : null;
+    return getLocalVideoStream(this.sipSessions[sessionId]);
   }
 
   // Remote streams
   getRemoteStream(sessionId: string): MediaStream | null {
-    const sipSession = this.sipSessions[sessionId];
-    return (sipSession?.sessionDescriptionHandler as SessionDescriptionHandler)?.remoteMediaStream || null;
+    return getRemoteStream(this.sipSessions[sessionId]);
   }
 
   getRemoteTracks(sessionId: string): MediaStreamTrack[] {
-    const remoteStream = this.getRemoteStream(sessionId);
-
-    if (!remoteStream) {
-      return [];
-    }
-
-    return remoteStream.getTracks();
+    return getRemoteTracks(this.sipSessions[sessionId]);
   }
 
   hasRemoteVideo(sessionId: string): boolean {
-    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: string): boolean {
-    return this.getRemoteTracks(sessionId).some(track => track.kind === 'video');
+    return hasARemoteVideoTrack(this.sipSessions[sessionId]);
   }
 
   getRemoteVideoStream(sessionId: string): MediaStream | null | undefined {
-    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: string): MediaStream | null | undefined {
-    const pc = this.getPeerConnection(sessionId) as PeerConnection;
-
-    if (!pc) {
-      return null;
-    }
-
-    return pc.getRemoteStreams().find((stream: MediaStream) => !!stream.getVideoTracks().length);
+    return getRemoteVideoStreamFromPc(this.sipSessions[sessionId]);
   }
 
   hasVideo(sessionId: string): boolean {
-    return this.hasLocalVideo(sessionId) || this.hasRemoteVideo(sessionId);
+    return hasVideoTrack(this.sipSessions[sessionId]);
   }
 
   hasAVideoTrack(sessionId: string): boolean {
-    return this.hasALocalVideoTrack(sessionId) || this.hasARemoteVideoTrack(sessionId);
-  }
-
-  getSipSessionId(sipSession: WazoSession | null | undefined): string {
-    if (!sipSession) {
-      return '';
-    }
-
-    const message = sipSession.message as Partial<{ callId?: string }>;
-    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(): Promise<void> {
     return new Promise(resolve => this.on(REGISTERED, resolve));
   }
 
-  // eslint-disable-next-line no-unused-vars
-  sessionWantsToDoVideo(session: WazoSession): boolean {
-    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(): boolean {
     return this.heartbeat.hasHeartbeat;
   }
@@ -1678,7 +1464,7 @@ export default class WebRTCClient extends Emitter {
   onCallEnded(session: WazoSession): void {
     this._cleanupMedia(session);
 
-    delete this.sipSessions[this.getSipSessionId(session)];
+    delete this.sipSessions[getSipSessionId(session)];
 
     this._stopSendingStats(session);
 
@@ -1697,7 +1483,7 @@ export default class WebRTCClient extends Emitter {
   }
 
   storeSipSession(session: WazoSession): void {
-    const id = this.getSipSessionId(session);
+    const id = getSipSessionId(session);
     logger.info('storing sip session', { id, clientId: this.clientId });
 
     this.sipSessions[id] = session;
@@ -1711,24 +1497,6 @@ export default class WebRTCClient extends Emitter {
     return Object.keys(this.sipSessions);
   }
 
-  setLocalMediaStream(sipSessionId: string, newStream: MediaStream): void {
-    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: string, newStream: MediaStream): Promise<void> {
     const sipSession = this.sipSessions[sipSessionId];
 
@@ -1744,84 +1512,15 @@ export default class WebRTCClient extends Emitter {
     });
 
     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: string, allTracks = true): void {
-    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: boolean, conference = false, constraints: Record<string, any> | null | undefined = null): Record<string, any> {
-    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: string): boolean {
     return sessionId in this.conferences;
   }
@@ -1913,30 +1612,16 @@ export default class WebRTCClient extends Emitter {
     }
   }
 
-  _isWeb(): boolean {
-    return typeof window === 'object' && typeof document === 'object';
-  }
-
-  _isVideoTrack(track: MediaStreamTrack): boolean {
-    return track.kind === 'video' && track.readyState === 'live';
-  }
-
   _hasAudio(): boolean {
     return this.hasAudio;
   }
 
   _getAudioConstraints(): MediaTrackConstraints | boolean {
-    // @ts-ignore: media constraints
-    return this.audio?.deviceId?.exact ? this.audio : true;
+    return getAudioConstraints(this.audio);
   }
 
   _getVideoConstraints(video = false): MediaTrackConstraints | boolean {
-    if (!video) {
-      return false;
-    }
-
-    // @ts-ignore: media constraints
-    return this.video?.deviceId?.exact ? this.video : true;
+    return getVideoConstraints(video && this.video);
   }
 
   _connectIfNeeded(): Promise<any> {
@@ -1999,101 +1684,9 @@ export default class WebRTCClient extends Emitter {
     }));
   }
 
-  _createUaOptions(uaOptionsOverrides: UserAgentConfigOverrides = {}): UserAgentOptions {
-    let {
-      host,
-    } = this.config;
-    let port: number | string = 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: UserAgentOptions = {
-      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: Session, options: SessionDescriptionHandlerFactoryOptions = {}) => {
-        const uaLogger = session.userAgent.getLogger('sip.WazoSessionDescriptionHandler');
-
-        const isWeb = this._isWeb();
-
-        const iceGatheringTimeout = 'peerConnectionOptions' in options ? (options.peerConnectionOptions as any).iceGatheringTimeout || DEFAULT_ICE_TIMEOUT : DEFAULT_ICE_TIMEOUT;
-        const sdhOptions: SessionDescriptionHandlerConfiguration = { ...options,
-          iceGatheringTimeout,
-          peerConnectionConfiguration: { ...defaultPeerConnectionConfiguration(),
-            ...(options.peerConnectionConfiguration || {}),
-          },
-        };
-        return new WazoSessionDescriptionHandler(uaLogger, wazoMediaStreamFactory, sdhOptions, isWeb, session as WazoSession);
-      },
-      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: WazoSession): void {
-    const sipSessionId = this.getSipSessionId(session);
+    const sipSessionId = getSipSessionId(session);
 
     // When receiving an Invitation, the delegate is not defined.
     if (!session.delegate) {
@@ -2102,7 +1695,7 @@ export default class WebRTCClient extends Emitter {
 
     session.delegate.onSessionDescriptionHandler = (sdh: SessionDescriptionHandler & { on: (type: string, e: any) => void }) => {
       sdh.on('error', (e: any) => {
-        this.eventEmitter.emit(ON_ERROR, e);
+        this.eventEmitter.emit(ON_ERROR, e, session);
       });
       sdh.peerConnectionDelegate = {
         onicecandidateerror: (error: Record<string, any>) => {
@@ -2157,7 +1750,7 @@ export default class WebRTCClient extends Emitter {
         session.outgoingInviteRequest.message.body.body = request.body;
       }
 
-      this.updateRemoteStream(sipSessionId, false);
+      updateRemoteStream(this.sipSessions[sipSessionId], false);
 
       await this._setupMedias(session);
 
@@ -2168,8 +1761,8 @@ export default class WebRTCClient extends Emitter {
   async _onProgress(session: WazoSession, early = false): Promise<void> {
     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,
@@ -2187,30 +1780,16 @@ export default class WebRTCClient extends Emitter {
 
     await this._setupMedias(session);
 
-    this.updateRemoteStream(this.getSipSessionId(session), initAllTracks);
-    const pc = (session.sessionDescriptionHandler as SessionDescriptionHandler)?.peerConnection;
+    updateRemoteStream(session, initAllTracks);
+    const pc = getPeerConnection(session);
 
     const onTrack = (event: RTCTrackEvent | MediaStreamTrackEvent) => {
-      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();
       }
 
@@ -2243,18 +1822,14 @@ export default class WebRTCClient extends Emitter {
     this._startSendingStats(session);
   }
 
-  _isAudioOnly(session: WazoSession): boolean {
-    return Boolean(session.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === stripVideo));
-  }
-
   async _setupMedias(session: WazoSession, newStream: MediaStream | null | undefined = null): Promise<void> {
-    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) {
@@ -2264,7 +1839,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);
     }
 
@@ -2309,11 +1884,11 @@ export default class WebRTCClient extends Emitter {
   }
 
   _cleanupMedia(session?: WazoSession): void {
-    const sessionId = this.getSipSessionId(session);
+    const sessionId = getSipSessionId(session);
     const localStream = this.getLocalStream(sessionId);
 
     if (localStream) {
-      this._cleanupStream(localStream);
+      cleanupStream(localStream);
     }
 
     const cleanLocalElement = (id: string) => {
@@ -2333,90 +1908,15 @@ export default class WebRTCClient extends Emitter {
       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: MediaStream): void {
-    stream.getTracks().filter(track => track.enabled).forEach(track => track.stop());
-  }
-
-  _toggleAudio(session: WazoSession, muteAudio: boolean): void {
-    const sdh = session.sessionDescriptionHandler as SessionDescriptionHandler;
-    const pc = (sdh?.peerConnection || null) as PeerConnection;
-
-    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: MediaStream) => {
-        stream.getAudioTracks().forEach(track => {
-          // eslint-disable-next-line
-          track.enabled = !muteAudio;
-        });
-      });
-    }
-  }
-
-  _toggleVideo(session: WazoSession, muteCamera: boolean): void {
-    const sdh = session.sessionDescriptionHandler as SessionDescriptionHandler;
-    const pc = sdh?.peerConnection as 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: MediaStream) => {
-        stream.getVideoTracks().forEach(track => {
-          // eslint-disable-next-line
-          track.enabled = !muteCamera;
-        });
-      });
-    }
-  }
-
-  /**
-   * @param pc RTCPeerConnection
-   */
-  _getRemoteStream(pc: PeerConnection): MediaStream | null {
-    let remoteStream: MediaStream | null = 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(): void {
     if (this.registerer) {
       // @ts-ignore: removeAllListeners does not exist
@@ -2433,7 +1933,7 @@ export default class WebRTCClient extends Emitter {
       return;
     }
 
-    const sessionId = this.getSipSessionId(session);
+    const sessionId = getSipSessionId(session);
     getStats(pc, (result: Record<string, any>) => {
       const {
         results,
@@ -2450,7 +1950,7 @@ export default class WebRTCClient extends Emitter {
   }
 
   _stopSendingStats(session: WazoSession): void {
-    const sessionId = this.getSipSessionId(session);
+    const sessionId = getSipSessionId(session);
     logger.trace('Check for stopping stats', {
       sessionId,
       ids: Object.keys(this.statsIntervals),
@@ -2465,10 +1965,6 @@ export default class WebRTCClient extends Emitter {
     }
   }
 
-  _makeURI(target: string): URI | undefined {
-    return UserAgent.makeURI(`sip:${target}@${this.config.host}`);
-  }
-
   async _disconnectTransport(force = false) {
     const transport = this.userAgent?.transport as WazoTransport;
 
@@ -2494,110 +1990,14 @@ export default class WebRTCClient extends Emitter {
   }
 
   async _fetchNetworkStats(sessionId: string): Promise<Record<string, any> | null | undefined> {
-    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: Record<string, any> = {
-      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]);