@wazo/sdk 0.43.15 → 0.44.1

package/lib/web-rtc-client.js

@@ -1,2239 +0,0 @@
-"use strict";
-/* eslint-disable class-methods-use-this, no-param-reassign, max-classes-per-file, no-underscore-dangle */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CanceledCallError = exports.transportEvents = exports.events = exports.replaceLocalIpModifier = void 0;
-/* global window, document, navigator */
-require("webrtc-adapter");
-const user_agent_state_1 = require("sip.js/lib/api/user-agent-state");
-const parser_1 = require("sip.js/lib/core/messages/parser");
-const constants_1 = require("sip.js/lib/core/messages/methods/constants");
-const uri_1 = require("sip.js/lib/grammar/uri");
-const user_agent_1 = require("sip.js/lib/api/user-agent");
-const modifiers_1 = require("sip.js/lib/platform/web/modifiers/modifiers");
-const session_dialog_1 = require("sip.js/lib/core/dialogs/session-dialog");
-const messager_1 = require("sip.js/lib/api/messager");
-const registerer_state_1 = require("sip.js/lib/api/registerer-state");
-const session_state_1 = require("sip.js/lib/api/session-state");
-const transport_state_1 = require("sip.js/lib/api/transport-state");
-const peer_connection_configuration_default_1 = require("sip.js/lib/platform/web/session-description-handler/peer-connection-configuration-default");
-const getstats_1 = __importDefault(require("getstats"));
-const api_1 = require("sip.js/lib/api");
-const WazoSessionDescriptionHandler_1 = __importStar(require("./lib/WazoSessionDescriptionHandler"));
-const Emitter_1 = __importDefault(require("./utils/Emitter"));
-const api_client_1 = __importDefault(require("./api-client"));
-const IssueReporter_1 = __importDefault(require("./service/IssueReporter"));
-const Heartbeat_1 = __importDefault(require("./utils/Heartbeat"));
-const sdp_1 = require("./utils/sdp");
-const array_1 = require("./utils/array");
-// We need to replace 0.0.0.0 to 127.0.0.1 in the sdp to avoid MOH during a createOffer.
-const replaceLocalIpModifier = (description) => Promise.resolve(Object.assign(Object.assign({}, JSON.parse(JSON.stringify(description))), { sdp: description.sdp.replace('c=IN IP4 0.0.0.0', 'c=IN IP4 127.0.0.1') }));
-exports.replaceLocalIpModifier = replaceLocalIpModifier;
-const DEFAULT_ICE_TIMEOUT = 3000;
-const SEND_STATS_DELAY = 5000;
-const states = ['STATUS_NULL', 'STATUS_NEW', 'STATUS_CONNECTING', 'STATUS_CONNECTED', 'STATUS_COMPLETED'];
-const logger = IssueReporter_1.default ? IssueReporter_1.default.loggerFor('webrtc-client') : console;
-const statsLogger = IssueReporter_1.default ? IssueReporter_1.default.loggerFor('webrtc-stats') : console;
-// events
-const REGISTERED = 'registered';
-const UNREGISTERED = 'unregistered';
-const REGISTRATION_FAILED = 'registrationFailed';
-const INVITE = 'invite';
-const CONNECTED = 'connected';
-const DISCONNECTED = 'disconnected';
-const TRANSPORT_ERROR = 'transportError';
-const MESSAGE = 'message';
-const ACCEPTED = 'accepted';
-const REJECTED = 'rejected';
-const ON_TRACK = 'onTrack';
-const ON_PROGRESS = 'onProgress';
-const ON_EARLY_MEDIA = 'onEarlyMedia';
-const ON_REINVITE = 'reinvite';
-const ON_ERROR = 'onError';
-const ON_SCREEN_SHARING_REINVITE = 'onScreenSharingReinvite';
-const ON_NETWORK_STATS = 'onNetworkStats';
-const ON_DISCONNECTED = 'onDisconnected';
-exports.events = [REGISTERED, UNREGISTERED, REGISTRATION_FAILED, INVITE];
-exports.transportEvents = [CONNECTED, DISCONNECTED, TRANSPORT_ERROR, MESSAGE];
-class CanceledCallError extends Error {
-}
-exports.CanceledCallError = CanceledCallError;
-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
-class WebRTCClient extends Emitter_1.default {
-    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
-        this.clientId = Math.ceil(Math.random() * 1000);
-        logger.info('sdk webrtc constructor', { clientId: this.clientId });
-        this.uaConfigOverrides = uaConfigOverrides;
-        this.config = config;
-        this.skipRegister = config.skipRegister;
-        this._buildConfig(config, session).then((newConfig) => {
-            this.config = newConfig;
-            this.userAgent = this.createUserAgent(uaConfigOverrides);
-        });
-        this.audioOutputDeviceId = config.audioDeviceOutput;
-        this.audioOutputVolume = config.audioOutputVolume || 1;
-        if (config.media) {
-            this.configureMedia(config.media);
-            this.setMediaConstraints({
-                audio: config.media.audio,
-                video: config.media.video,
-            });
-        }
-        this.heldSessions = {};
-        this.statsIntervals = {};
-        this.connectionPromise = null;
-        this.sipSessions = {};
-        this.conferences = {};
-        this.networkMonitoringInterval = {};
-        this.sessionNetworkStats = {};
-        this.forceClosed = false;
-        this._boundOnHeartbeat = this._onHeartbeat.bind(this);
-        this.heartbeat = new Heartbeat_1.default(config.heartbeatDelay, config.heartbeatTimeout, config.maxHeartbeats);
-        this.heartbeat.setSendHeartbeat(this.pingServer.bind(this));
-        this.heartbeat.setOnHeartbeatTimeout(this._onHeartbeatTimeout.bind(this));
-        // sugar
-        this.REGISTERED = REGISTERED;
-        this.UNREGISTERED = UNREGISTERED;
-        this.REGISTRATION_FAILED = REGISTRATION_FAILED;
-        this.INVITE = INVITE;
-        this.CONNECTED = CONNECTED;
-        this.DISCONNECTED = DISCONNECTED;
-        this.TRANSPORT_ERROR = TRANSPORT_ERROR;
-        this.MESSAGE = MESSAGE;
-        this.ACCEPTED = ACCEPTED;
-        this.REJECTED = REJECTED;
-        this.ON_TRACK = ON_TRACK;
-        this.ON_REINVITE = ON_REINVITE;
-        this.ON_ERROR = ON_ERROR;
-        this.ON_SCREEN_SHARING_REINVITE = ON_SCREEN_SHARING_REINVITE;
-        this.ON_NETWORK_STATS = ON_NETWORK_STATS;
-        this.ON_DISCONNECTED = ON_DISCONNECTED;
-        this.ON_EARLY_MEDIA = ON_EARLY_MEDIA;
-        this.ON_PROGRESS = ON_PROGRESS;
-    }
-    configureMedia(media) {
-        this.hasAudio = !!media.audio;
-        this.audioStreams = {};
-        this.audioElements = {};
-    }
-    setMediaConstraints(media) {
-        this.video = media.video;
-        this.audio = media.audio;
-    }
-    createUserAgent(uaConfigOverrides) {
-        var _a;
-        const uaOptions = this._createUaOptions(uaConfigOverrides);
-        logger.info('sdk webrtc, creating UA', {
-            uaOptions: Object.assign(Object.assign({}, uaOptions), { authorizationPassword: `${(_a = uaOptions === null || uaOptions === void 0 ? void 0 : uaOptions.authorizationPassword) === null || _a === void 0 ? void 0 : _a.slice(0, 5)}xxxx` }),
-            clientId: this.clientId,
-        });
-        uaOptions.delegate = {
-            onConnect: this.onConnect.bind(this),
-            onDisconnect: this.onDisconnect.bind(this),
-            onInvite: (invitation) => {
-                logger.info('sdk webrtc on invite', {
-                    method: 'delegate.onInvite',
-                    clientId: this.clientId,
-                    id: this.getSipSessionId(invitation),
-                    remoteURI: invitation.remoteURI,
-                });
-                this._setupSession(invitation);
-                const shouldAutoAnswer = !!invitation.request.getHeader('alert-info');
-                this.eventEmitter.emit(INVITE, invitation, this.sessionWantsToDoVideo(invitation), shouldAutoAnswer);
-            },
-        };
-        const ua = new user_agent_1.UserAgent(uaOptions);
-        ua.start();
-        if (ua.transport && ua.transport.connectPromise) {
-            ua.transport.connectPromise.catch((e) => {
-                logger.warn('Transport connect error', e);
-            });
-        }
-        ua.transport.onMessage = (rawMessage) => {
-            const message = parser_1.Parser.parseMessage(rawMessage, ua.transport.logger);
-            // We have to re-sent the message to the UA ...
-            // @ts-ignore: private
-            ua.onTransportMessage(rawMessage);
-            // And now do what we want with the message
-            this.eventEmitter.emit(MESSAGE, message);
-            if (message && message.method === constants_1.C.MESSAGE) {
-                // We have to manually reply to MESSAGE with a 200 OK or Asterisk will hangup.
-                ua.userAgentCore.replyStateless(message, {
-                    statusCode: 200,
-                });
-            }
-        };
-        return ua;
-    }
-    isConnected() {
-        var _a;
-        return Boolean((_a = this.userAgent) === null || _a === void 0 ? void 0 : _a.isConnected());
-    }
-    isConnecting() {
-        var _a, _b;
-        return ((_b = (_a = this.userAgent) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.state) === transport_state_1.TransportState.Connecting;
-    }
-    isRegistered() {
-        return Boolean(this.registerer && this.registerer.state === registerer_state_1.RegistererState.Registered);
-    }
-    onConnect() {
-        var _a;
-        logger.info('sdk webrtc connected', { method: 'delegate.onConnect', clientId: this.clientId });
-        this.eventEmitter.emit(CONNECTED);
-        // @ts-ignore: private
-        if (!this.isRegistered() && ((_a = this.registerer) === null || _a === void 0 ? void 0 : _a.waiting)) {
-            // @ts-ignore: private
-            this.registerer.waitingToggle(false);
-        }
-        return this.register();
-    }
-    onDisconnect(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            logger.info('sdk webrtc disconnected', { method: 'delegate.onConnect', clientId: this.clientId, error });
-            this.connectionPromise = null;
-            // The UA will attempt to reconnect automatically when an error occurred
-            this.eventEmitter.emit(DISCONNECTED, error);
-            if (this.isRegistered()) {
-                yield this.unregister();
-                // @ts-ignore: private
-                if ((_a = this.registerer) === null || _a === void 0 ? void 0 : _a.waiting) {
-                    // @ts-ignore: private
-                    this.registerer.waitingToggle(false);
-                }
-                this.eventEmitter.emit(UNREGISTERED);
-            }
-        });
-    }
-    register() {
-        return __awaiter(this, arguments, void 0, function* (tries = 0) {
-            var _a;
-            const logInfo = {
-                clientId: this.clientId,
-                userAgent: !!this.userAgent,
-                registered: this.isRegistered(),
-                connectionPromise: !!this.connectionPromise,
-                registerer: !!this.registerer,
-                // @ts-ignore: private
-                waiting: this.registerer && this.registerer.waiting,
-                tries,
-                skipRegister: this.skipRegister,
-            };
-            this.forceClosed = false;
-            if (this.skipRegister) {
-                logger.info('sdk webrtc skip register...', logInfo);
-                return Promise.resolve();
-            }
-            logger.info('sdk webrtc registering...', logInfo);
-            if (!this.userAgent) {
-                logger.info('sdk webrtc recreating User Agent');
-                this.userAgent = this.createUserAgent(this.uaConfigOverrides);
-            }
-            if (!this.userAgent || this.isRegistered()) {
-                logger.info('sdk webrtc registering aborted, already registered or no UA can be created');
-                return Promise.resolve();
-            }
-            // @ts-ignore: private
-            if (this.connectionPromise || ((_a = this.registerer) === null || _a === void 0 ? void 0 : _a.waiting)) {
-                logger.info('sdk webrtc registering aborted due to a registration in progress.', { clientId: this.clientId });
-                return Promise.resolve();
-            }
-            const registerOptions = this._isWeb() ? {} : {
-                extraContactHeaderParams: ['mobility=mobile'],
-            };
-            const onRegisterFailed = () => {
-                logger.info('sdk webrtc registering failed', {
-                    tries,
-                    clientId: this.clientId,
-                    registerer: !!this.registerer,
-                    forceClosed: this.forceClosed,
-                });
-                if (this.forceClosed) {
-                    return;
-                }
-                this.connectionPromise = null;
-                // @ts-ignore: private
-                if (this.registerer && this.registerer.waiting) {
-                    // @ts-ignore: private
-                    this.registerer.waitingToggle(false);
-                }
-                if (tries <= MAX_REGISTER_TRIES) {
-                    logger.info('sdk webrtc registering, retrying...', { clientId: this.clientId, tries });
-                    setTimeout(() => this.register(tries + 1), 300);
-                }
-            };
-            return this._connectIfNeeded().then(() => {
-                // Avoid race condition with the close method called just before register and setting userAgent to null
-                // during the resolution of the promise.
-                if (!this.userAgent) {
-                    logger.info('sdk webrtc recreating User Agent after connection');
-                    this.userAgent = this.createUserAgent(this.uaConfigOverrides);
-                }
-                logger.info('sdk webrtc registering, transport connected', { registerOptions, ua: !!this.userAgent, clientId: this.clientId });
-                this.registerer = new api_1.Registerer(this.userAgent, registerOptions);
-                this.connectionPromise = null;
-                this._monkeyPatchRegisterer(this.registerer);
-                // Bind registerer events
-                this.registerer.stateChange.addListener(newState => {
-                    logger.info('sdk webrtc registering, state changed', { newState, clientId: this.clientId });
-                    if (newState === registerer_state_1.RegistererState.Registered && this.registerer && this.registerer.state === registerer_state_1.RegistererState.Registered) {
-                        this.eventEmitter.emit(REGISTERED);
-                    }
-                    else if (newState === registerer_state_1.RegistererState.Unregistered) {
-                        this.eventEmitter.emit(UNREGISTERED);
-                    }
-                });
-                const options = {
-                    requestDelegate: {
-                        onReject: (response) => {
-                            logger.error('sdk webrtc registering, rejected', { clientId: this.clientId, response });
-                            onRegisterFailed();
-                        },
-                    },
-                };
-                return this.registerer.register(options).catch(e => {
-                    logger.error('sdk webrtc registering, error', e);
-                    this.eventEmitter.emit(REGISTRATION_FAILED);
-                    return e;
-                });
-            }).catch(error => {
-                logger.error('sdk webrtc registering, transport error', error);
-                onRegisterFailed();
-            });
-        });
-    }
-    // Monkey patching sip.js to avoid issues during register.onReject
-    _monkeyPatchRegisterer(registerer) {
-        if (!registerer) {
-            return;
-        }
-        // @ts-ignore: private
-        const oldWaitingToggle = registerer.waitingToggle.bind(registerer);
-        // @ts-ignore: private
-        const oldUnregistered = registerer.unregistered.bind(registerer);
-        // @ts-ignore: private
-        registerer.waitingToggle = (waiting) => {
-            // @ts-ignore: private
-            if (!registerer || registerer.waiting === waiting) {
-                return;
-            }
-            oldWaitingToggle(waiting);
-        };
-        // @ts-ignore: private
-        registerer.unregistered = () => {
-            if (!registerer || registerer.state === registerer_state_1.RegistererState.Terminated) {
-                return;
-            }
-            oldUnregistered();
-        };
-    }
-    unregister() {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger.info('sdk webrtc unregistering..', {
-                clientId: this.clientId,
-                userAgent: !!this.userAgent,
-                registerer: !!this.registerer,
-            });
-            try {
-                return new Promise((resolve, reject) => {
-                    if (!this.registerer) {
-                        return resolve();
-                    }
-                    const onRegisterStateChange = (state) => {
-                        if (state === registerer_state_1.RegistererState.Unregistered) {
-                            logger.info('sdk webrtc unregistered', { clientId: this.clientId });
-                            if (this.registerer) {
-                                this.registerer.stateChange.addListener(onRegisterStateChange);
-                            }
-                            this._cleanupRegister();
-                            resolve();
-                        }
-                    };
-                    this.registerer.stateChange.addListener(onRegisterStateChange);
-                    this.registerer.unregister().then().catch(e => {
-                        logger.error('sdk webrtc unregistering, promise error', e);
-                        this._cleanupRegister();
-                        reject();
-                    });
-                });
-            }
-            catch (e) {
-                logger.error('sdk webrtc unregistering, error', e);
-                // Avoid issue with `undefined is not an object (evaluating 'new.target.prototype')` when triggering a new
-                // error when the registerer is in a bad state
-                this._cleanupRegister();
-            }
-        });
-    }
-    stop() {
-        logger.info('sdk webrtc stop', { clientId: this.clientId, userAgent: !!this.userAgent });
-        if (!this.userAgent) {
-            return Promise.resolve();
-        }
-        return this.userAgent.stop().then(() => {
-            return this._cleanupRegister();
-        }).catch(e => {
-            logger.warn('sdk webrtc stop, error', {
-                message: e.message,
-                stack: e.stack,
-            });
-        });
-    }
-    call(number, enableVideo, audioOnly = false, conference = false, options = {}) {
-        logger.info('sdk webrtc creating call', {
-            clientId: this.clientId,
-            number,
-            enableVideo,
-            audioOnly,
-            conference,
-            options,
-        });
-        const inviterOptions = Object.assign({ sessionDescriptionHandlerOptionsReInvite: {
-                conference,
-                audioOnly,
-            }, earlyMedia: true }, options);
-        if (audioOnly) {
-            inviterOptions.sessionDescriptionHandlerModifiersReInvite = [modifiers_1.stripVideo];
-        }
-        const uri = this._makeURI(number);
-        let session = null;
-        if (uri) {
-            session = this.userAgent ? new api_1.Inviter(this.userAgent, uri, inviterOptions) : null;
-        }
-        else {
-            logger.error('Null URI');
-        }
-        if (session) {
-            this.storeSipSession(session);
-            this._setupSession(session);
-        }
-        if (conference) {
-            this.conferences[this.getSipSessionId(session)] = true;
-        }
-        const inviteOptions = {
-            requestDelegate: {
-                onAccept: (response) => {
-                    var _a;
-                    if ((_a = session === null || session === void 0 ? void 0 : session.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.peerConnection) {
-                        (session === null || session === void 0 ? void 0 : session.sessionDescriptionHandler).peerConnection.sfu = conference;
-                    }
-                    this._onAccepted(session, response.session, true);
-                },
-                onProgress: (payload) => {
-                    this._onProgress(payload.session, payload.message.statusCode === 183);
-                },
-                onReject: (response) => {
-                    logger.info('on call rejected', {
-                        id: this.getSipSessionId(session),
-                        // @ts-ignore: fromTag does not exist
-                        fromTag: session === null || session === void 0 ? void 0 : session.fromTag,
-                    });
-                    this._stopSendingStats(session);
-                    this.stopNetworkMonitoring(session);
-                    this.eventEmitter.emit(REJECTED, session, response);
-                },
-            },
-            sessionDescriptionHandlerOptions: this.getMediaConfiguration(enableVideo || false, conference),
-        };
-        if (inviteOptions.sessionDescriptionHandlerOptions) {
-            inviteOptions.sessionDescriptionHandlerOptions.audioOnly = audioOnly;
-        }
-        inviteOptions.sessionDescriptionHandlerModifiers = [exports.replaceLocalIpModifier];
-        if (audioOnly) {
-            inviteOptions.sessionDescriptionHandlerModifiers.push(modifiers_1.stripVideo);
-        }
-        if (session) {
-            // Do not await invite here or we'll miss the Establishing state transition
-            // @ts-ignore: Property 'invitePromise' does not exist
-            session.invitePromise = session.invite(inviteOptions).catch((e) => {
-                logger.warn('sdk webrtc creating call, error', e);
-            });
-        }
-        return session;
-    }
-    answer(session, enableVideo) {
-        logger.info('sdk webrtc answer call', {
-            clientId: this.clientId,
-            id: this.getSipSessionId(session),
-            enableVideo,
-        });
-        if (!session || !session.accept) {
-            const error = 'No session to answer, or not an invitation';
-            logger.warn(error);
-            return Promise.reject(new Error(error));
-        }
-        const options = {
-            sessionDescriptionHandlerOptions: this.getMediaConfiguration(enableVideo || false),
-        };
-        return this._accept(session, options).then(() => {
-            // @ts-ignore: private
-            if (session.isCanceled) {
-                const message = 'accepted a canceled session (or was canceled during the accept phase).';
-                logger.error(message, {
-                    id: this.getSipSessionId(session),
-                });
-                this.onCallEnded(session);
-                throw new CanceledCallError(message);
-            }
-            logger.info('sdk webrtc answer, accepted.');
-            this._onAccepted(session);
-        }).catch(e => {
-            logger.error(`answer call error for ${this.getSipSessionId(session)}`, e);
-            throw e;
-        });
-    }
-    hangup(session) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { state, id } = session;
-            logger.info('sdk webrtc hangup call', { clientId: this.clientId, id, state });
-            try {
-                this._stopSendingStats(session);
-                this._cleanupMedia(session);
-                delete this.sipSessions[this.getSipSessionId(session)];
-                // Check if Invitation or Inviter (Invitation = incoming call)
-                const isInviter = session instanceof api_1.Inviter;
-                // @see github.com/onsip/SIP.js/blob/f11dfd584bc9788ccfc94e03034020672b738975/src/platform/web/simple-user/simple-user.ts#L1004
-                const actions = {
-                    [session_state_1.SessionState.Initial]: isInviter ? this._cancel.bind(this, session) : this._reject.bind(this, session),
-                    [session_state_1.SessionState.Establishing]: isInviter ? this._cancel.bind(this, session) : this._reject.bind(this, session),
-                    [session_state_1.SessionState.Established]: this._bye.bind(this, session),
-                };
-                // Handle different session status
-                if (actions[state]) {
-                    return yield actions[state]();
-                }
-                return yield this._bye(session);
-            }
-            catch (error) {
-                logger.warn('sdk webrtc hangup, error', error);
-            }
-            return Promise.resolve(null);
-        });
-    }
-    getStats(session) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const pc = (_a = session.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.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);
-        logger.info('starting network inspection', {
-            id: sessionId,
-            clientId: this.clientId,
-        });
-        this.sessionNetworkStats[sessionId] = [];
-        this.networkMonitoringInterval[sessionId] = setInterval(() => this._fetchNetworkStats(sessionId), interval);
-    }
-    stopNetworkMonitoring(session) {
-        const sessionId = this.getSipSessionId(session);
-        const exists = (sessionId in this.networkMonitoringInterval);
-        logger.info('stopping network inspection', {
-            clientId: this.clientId,
-            id: sessionId,
-            exists,
-        });
-        if (exists) {
-            clearInterval(this.networkMonitoringInterval[sessionId]);
-            delete this.networkMonitoringInterval[sessionId];
-            delete this.sessionNetworkStats[sessionId];
-        }
-    }
-    reject(session) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger.info('sdk webrtc reject call', {
-                clientId: this.clientId,
-                id: this.getSipSessionId(session),
-            });
-            try {
-                if (session instanceof api_1.Invitation) {
-                    return this._reject(session);
-                }
-                if (session instanceof api_1.Inviter) {
-                    return this._cancel(session);
-                }
-            }
-            catch (e) {
-                logger.warn('Error when rejecting call', e.message, e.stack);
-            }
-        });
-    }
-    close() {
-        return __awaiter(this, arguments, void 0, function* (force = false) {
-            logger.info('sdk webrtc closing client', {
-                clientId: this.clientId,
-                userAgent: !!this.userAgent,
-                force,
-            });
-            this.forceClosed = force;
-            this._cleanupMedia();
-            this.connectionPromise = null;
-            Object.values(this.audioElements).forEach((audioElement) => {
-                // eslint-disable-next-line
-                audioElement.srcObject = null;
-                audioElement.pause();
-            });
-            this.audioElements = {};
-            if (!this.userAgent) {
-                return;
-            }
-            this.stopHeartbeat();
-            if (this.userAgent) {
-                this.userAgent.delegate = undefined;
-            }
-            // @ts-ignore: removeAllListeners does not exist
-            this.userAgent.stateChange.removeAllListeners();
-            yield this._disconnectTransport(force);
-            this._cleanupRegister();
-            try {
-                // Prevent `Connect aborted.` error when disconnecting
-                this.userAgent.transport.connectReject = () => { };
-                // Don't wait here, It can take ~30s to stop ...
-                this.userAgent.stop().catch(console.error);
-            }
-            catch (_) { // Avoid to raise exception when trying to close with hanged-up sessions remaining
-                // eg: "INVITE not rejectable in state Completed"
-            }
-            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: this.getSipSessionId(session),
-        });
-        this._toggleAudio(session, true);
-    }
-    unmute(session) {
-        logger.info('sdk webrtc unmute', {
-            id: this.getSipSessionId(session),
-        });
-        this._toggleAudio(session, false);
-    }
-    isAudioMuted(session) {
-        if (!session || !session.sessionDescriptionHandler) {
-            return false;
-        }
-        let muted = true;
-        const pc = session.sessionDescriptionHandler.peerConnection;
-        if (!pc) {
-            return false;
-        }
-        if (pc.getSenders) {
-            if (!pc.getSenders().length) {
-                return false;
-            }
-            pc.getSenders().forEach((sender) => {
-                if (sender && sender.track && sender.track.kind === 'audio') {
-                    muted = muted && !sender.track.enabled;
-                }
-            });
-        }
-        else {
-            if (!pc.getLocalStreams().length) {
-                return false;
-            }
-            pc.getLocalStreams().forEach((stream) => {
-                stream.getAudioTracks().forEach(track => {
-                    muted = muted && !track.enabled;
-                });
-            });
-        }
-        return muted;
-    }
-    toggleCameraOn(session) {
-        logger.info('sdk webrtc toggle camera on', {
-            id: this.getSipSessionId(session),
-        });
-        this._toggleVideo(session, false);
-    }
-    toggleCameraOff(session) {
-        logger.info('sdk webrtc toggle camera off', {
-            id: this.getSipSessionId(session),
-        });
-        this._toggleVideo(session, true);
-    }
-    hold(session, isConference = false, hadVideo = false) {
-        const sessionId = this.getSipSessionId(session);
-        const hasVideo = hadVideo || this.hasLocalVideo(sessionId);
-        logger.info('sdk webrtc hold', {
-            sessionId,
-            keys: Object.keys(this.heldSessions),
-            // @ts-ignore: private
-            pendingReinvite: !!session.pendingReinvite,
-            isConference,
-            hasVideo,
-        });
-        if (sessionId in this.heldSessions) {
-            return Promise.resolve();
-        }
-        // @ts-ignore: private
-        if (session.pendingReinvite) {
-            return Promise.resolve();
-        }
-        this.heldSessions[sessionId] = {
-            hasVideo,
-            isConference,
-        };
-        // We should also mute the call, because when holding a call during a voicemail, the audio is still sent with the
-        // `sendonly` direction
-        this.mute(session);
-        session.sessionDescriptionHandlerOptionsReInvite = {
-            hold: true,
-            conference: isConference,
-        };
-        const options = this.getMediaConfiguration(false, isConference);
-        if (!this._isWeb()) {
-            options.sessionDescriptionHandlerModifiers = [modifiers_1.holdModifier];
-        }
-        options.sessionDescriptionHandlerOptions = {
-            constraints: options.constraints,
-            hold: true,
-            conference: isConference,
-        };
-        // Avoid sdh to create a new stream
-        if (session.sessionDescriptionHandler) {
-            // @ts-ignore: private
-            session.sessionDescriptionHandler.localMediaStreamConstraints = options.constraints;
-        }
-        // Send re-INVITE
-        return session.invite(options).catch((e) => {
-            logger.warn('sdk webrtc re-invite during hold, error', e);
-        });
-    }
-    unhold(session, isConference = false) {
-        const sessionId = this.getSipSessionId(session);
-        const hasVideo = sessionId in this.heldSessions && this.heldSessions[sessionId].hasVideo;
-        logger.info('sdk webrtc unhold', {
-            sessionId,
-            keys: Object.keys(this.heldSessions),
-            // @ts-ignore: private
-            pendingReinvite: !!session.pendingReinvite,
-            isConference,
-            hasVideo,
-        });
-        // @ts-ignore: private
-        if (session.pendingReinvite) {
-            return Promise.resolve();
-        }
-        this.unmute(session);
-        delete this.heldSessions[this.getSipSessionId(session)];
-        session.sessionDescriptionHandlerOptionsReInvite = {
-            hold: false,
-            conference: isConference,
-        };
-        const options = this.getMediaConfiguration(false, isConference);
-        if (!this._isWeb()) {
-            // We should sent an empty `sessionDescriptionHandlerModifiers` or sip.js will take the last sent modifiers
-            // (eg: holdModifier)
-            options.sessionDescriptionHandlerModifiers = [];
-        }
-        options.sessionDescriptionHandlerOptions = {
-            constraints: options.constraints,
-            hold: false,
-            conference: isConference,
-        };
-        // Send re-INVITE
-        return session.invite(options).catch((e) => {
-            logger.warn('sdk webrtc re-invite during resume, error', e);
-        });
-    }
-    // Returns true if a re-INVITE is required
-    upgradeToVideo(session, constraints, isConference) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const pc = (_a = session.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.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 === null || pc === void 0 ? void 0 : pc.getTransceivers()) || [];
-                const transceiverIdx = (0, array_1.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 = yield 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 = (_b = session.sessionDescriptionHandler) === null || _b === void 0 ? void 0 : _b.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 === null || sessionDescriptionHandler === void 0 ? void 0 : sessionDescriptionHandler.localMediaStream;
-        const pc = sessionDescriptionHandler === null || sessionDescriptionHandler === void 0 ? void 0 : sessionDescriptionHandler.peerConnection;
-        const videoTracks = localStream.getVideoTracks();
-        // Remove video senders
-        if (pc === null || pc === void 0 ? void 0 : 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);
-        });
-    }
-    getStreamFromConstraints(constraints_1) {
-        return __awaiter(this, arguments, void 0, function* (constraints, conference = false) {
-            const video = constraints && constraints.video;
-            const { constraints: newConstraints, } = this.getMediaConfiguration(video, conference, constraints);
-            let newStream = null;
-            try {
-                newStream = yield (0, WazoSessionDescriptionHandler_1.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;
-    }
-    isVideoRemotelyHeld(sessionId) {
-        const pc = this.getPeerConnection(sessionId);
-        const sdp = pc && pc.remoteDescription ? pc.remoteDescription.sdp : null;
-        if (!sdp) {
-            return false;
-        }
-        const videoDirection = (0, sdp_1.getVideoDirection)(sdp);
-        return videoDirection === 'sendonly';
-    }
-    sendDTMF(session, tone) {
-        if (!session.sessionDescriptionHandler) {
-            return false;
-        }
-        logger.info('Sending DTMF', {
-            id: this.getSipSessionId(session),
-            tone,
-        });
-        return session.sessionDescriptionHandler.sendDtmf(tone);
-    }
-    message(destination, message) {
-        const uri = this._makeURI(destination);
-        if (!this.userAgent || !uri) {
-            logger.warn('Null value on message', { uri, userAgent: this.userAgent });
-            return;
-        }
-        const messager = new messager_1.Messager(this.userAgent, uri, message);
-        messager.message();
-    }
-    transfer(session, target) {
-        this.hold(session);
-        logger.info('Transfering a session', {
-            id: this.getSipSessionId(session),
-            target,
-        });
-        const options = {
-            requestDelegate: {
-                onAccept: () => {
-                    this.hangup(session);
-                },
-            },
-        };
-        setTimeout(() => {
-            const uri = this._makeURI(target);
-            if (!uri) {
-                logger.warn('transfer timeout: null URI');
-                return;
-            }
-            session.refer(uri, options);
-        }, 50);
-    }
-    // check https://sipjs.com/api/0.12.0/refer/referClientContext/
-    atxfer(session) {
-        this.hold(session);
-        logger.info('webrtc transfer started', {
-            id: this.getSipSessionId(session),
-        });
-        const result = {
-            newSession: null,
-            init: (target) => __awaiter(this, void 0, void 0, function* () {
-                logger.info('webrtc transfer initialized', {
-                    id: this.getSipSessionId(session),
-                    target,
-                });
-                result.newSession = yield this.call(target);
-            }),
-            complete: () => {
-                logger.info('webrtc transfer completed', {
-                    id: this.getSipSessionId(session),
-                    referId: this.getSipSessionId(result.newSession),
-                });
-                session.refer(result.newSession);
-            },
-            cancel: () => {
-                this.hangup(result.newSession);
-                this.unhold(session);
-            },
-        };
-        return result;
-    }
-    // eslint-disable-next-line @typescript-eslint/default-param-last
-    sendMessage(sipSession = null, body, contentType = 'text/plain') {
-        if (!sipSession) {
-            return;
-        }
-        logger.info('send WebRTC message', {
-            sipId: this.getSipSessionId(sipSession),
-            contentType,
-        });
-        try {
-            sipSession.message({
-                requestOptions: {
-                    body: {
-                        content: body,
-                        contentType,
-                        // @HEADSUP: contentDisposition is a required string, setting it to '' arbitrarily
-                        contentDisposition: '',
-                    },
-                },
-            });
-        }
-        catch (e) {
-            console.warn(e);
-        }
-    }
-    pingServer() {
-        var _a;
-        if (!this.isConnected()) {
-            return;
-        }
-        const core = (_a = this.userAgent) === null || _a === void 0 ? void 0 : _a.userAgentCore;
-        const fromURI = this._makeURI(this.config.authorizationUser || '');
-        const toURI = new uri_1.URI('sip', '', this.config.host);
-        if (fromURI) {
-            const message = core === null || core === void 0 ? void 0 : core.makeOutgoingRequestMessage('OPTIONS', toURI, fromURI, toURI, {});
-            if (message) {
-                return core === null || core === void 0 ? void 0 : core.request(message);
-            }
-            logger.warn('pingServer: null message');
-        }
-        logger.warn('pingServer: null fromURI');
-    }
-    getState() {
-        // @ts-ignore: something fishy here: `states` content doesn't match UserAgentState at all
-        return this.userAgent ? states[this.userAgent.state] : user_agent_state_1.UserAgentState.Stopped;
-    }
-    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,
-        });
-        Object.values(this.audioElements).forEach(audioElement => {
-            if (audioElement instanceof HTMLAudioElement) {
-                // eslint-disable-next-line no-param-reassign
-                audioElement.volume = volume;
-            }
-        });
-        this.audioOutputVolume = volume;
-    }
-    changeAudioOutputDevice(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger.info('Changing audio output device', {
-                id,
-            });
-            this.audioOutputDeviceId = id;
-            const promises = [];
-            Object.values(this.audioElements).forEach(audioElement => promises.push(audioElement.setSinkId(id)));
-            yield Promise.allSettled(promises);
-        });
-    }
-    changeAudioInputDevice(id, session, force) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentId = this.getAudioDeviceId();
-            logger.info('setting audio input device', {
-                id,
-                currentId,
-                session: !!session,
-            });
-            if (!force && id === currentId) {
-                return null;
-            }
-            // in order to handle an audio track change for default devices
-            // we need the actual id of the device (not 'default')
-            let deviceId = id;
-            if (id === 'default' && navigator.mediaDevices) {
-                const devices = yield navigator.mediaDevices.enumerateDevices();
-                const defaultDevice = devices.find(device => device.deviceId === 'default');
-                if (defaultDevice) {
-                    const deviceLabel = defaultDevice.label.replace('Default - ', '');
-                    const targetDevice = devices.find(device => device.label === deviceLabel);
-                    if (targetDevice) {
-                        deviceId = targetDevice.deviceId;
-                        if (!force && deviceId === currentId) {
-                            return null;
-                        }
-                    }
-                }
-            }
-            // let's update the local audio value
-            if (this.audio) {
-                this.audio = {
-                    deviceId: {
-                        exact: deviceId,
-                    },
-                };
-            }
-            if (session && navigator.mediaDevices) {
-                const sdh = session.sessionDescriptionHandler;
-                const pc = sdh === null || sdh === void 0 ? void 0 : sdh.peerConnection;
-                const constraints = {
-                    audio: {
-                        deviceId: {
-                            exact: deviceId,
-                        },
-                    },
-                };
-                const stream = yield navigator.mediaDevices.getUserMedia(constraints);
-                const audioTrack = stream.getAudioTracks()[0];
-                const sender = pc && pc.getSenders && pc.getSenders().find((s) => audioTrack && s && s.track && s.track.kind === audioTrack.kind);
-                if (sender) {
-                    if (sender.track) {
-                        audioTrack.enabled = sender.track.enabled;
-                    }
-                    sender.replaceTrack(audioTrack);
-                }
-                return stream;
-            }
-            return null;
-        });
-    }
-    changeVideoInputDevice(id, session) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.setVideoInputDevice(id);
-            if (session) {
-                return this.changeSessionVideoInputDevice(id, session);
-            }
-        });
-    }
-    setVideoInputDevice(id) {
-        const currentId = this.getVideoDeviceId();
-        logger.info('setting video input device', {
-            id,
-            currentId,
-        });
-        if (id === currentId) {
-            return null;
-        }
-        // let's make sure we don't lose other video constraints settings -- width, height, frameRate...
-        const videoObject = typeof this.video === 'object' ? this.video : {};
-        this.video = Object.assign(Object.assign({}, videoObject), { deviceId: {
-                exact: id,
-            } });
-    }
-    changeSessionVideoInputDevice(id, session) {
-        if (!this.sessionWantsToDoVideo(session)) {
-            return Promise.resolve();
-        }
-        const sdh = session.sessionDescriptionHandler;
-        const pc = sdh.peerConnection;
-        const sessionId = this.getSipSessionId(session);
-        const localStream = this.getLocalStream(sessionId);
-        logger.info('changing video input device', {
-            id,
-            sessionId,
-        });
-        // Release old video stream
-        if (localStream) {
-            localStream.getVideoTracks()
-                .filter((track) => track.enabled)
-                .forEach((track) => track.stop());
-        }
-        const constraints = {
-            video: id ? {
-                deviceId: {
-                    exact: id,
-                },
-            } : true,
-        };
-        return navigator.mediaDevices.getUserMedia(constraints).then((stream) => __awaiter(this, void 0, void 0, function* () {
-            const videoTrack = stream.getVideoTracks()[0];
-            let sender = pc && pc.getSenders && pc.getSenders().find((s) => videoTrack && s && s.track && s.track.kind === videoTrack.kind);
-            let wasTrackEnabled = false;
-            if (!sender) {
-                sender = pc && pc.getSenders && pc.getSenders().find((s) => !s.track);
-            }
-            if (sender) {
-                // No video track means video not enabled
-                wasTrackEnabled = sender.track ? sender.track.enabled : false;
-                videoTrack.enabled = wasTrackEnabled;
-                if (!wasTrackEnabled) {
-                    videoTrack.stop();
-                }
-                sender.replaceTrack(wasTrackEnabled ? videoTrack : null);
-            }
-            // let's update the local stream
-            this.eventEmitter.emit('onVideoInputChange', stream);
-            this.setLocalMediaStream(sessionId, stream);
-            return stream;
-        }));
-    }
-    getAudioDeviceId() {
-        var _a;
-        return this.audio && typeof this.audio === 'object' && 'deviceId' in this.audio ? (_a = this.audio.deviceId) === null || _a === void 0 ? void 0 : _a.exact : undefined;
-    }
-    getVideoDeviceId() {
-        var _a;
-        return this.video && typeof this.video === 'object' && 'deviceId' in this.video ? (_a = this.video.deviceId) === null || _a === void 0 ? void 0 : _a.exact : undefined;
-    }
-    reinvite(sipSession, newConstraints = null, conference = false, audioOnly = false, iceRestart = false) {
-        if (!sipSession) {
-            return Promise.resolve();
-        }
-        // @ts-ignore: private
-        if (sipSession.pendingReinvite) {
-            return Promise.resolve();
-        }
-        const wasMuted = this.isAudioMuted(sipSession);
-        const shouldDoVideo = newConstraints ? newConstraints.video : this.sessionWantsToDoVideo(sipSession);
-        const shouldDoScreenSharing = newConstraints && newConstraints.screen;
-        const desktop = newConstraints && newConstraints.desktop;
-        logger.info('Sending reinvite', {
-            clientId: this.clientId,
-            id: this.getSipSessionId(sipSession),
-            newConstraints,
-            conference,
-            audioOnly,
-            wasMuted,
-            shouldDoVideo,
-            shouldDoScreenSharing,
-            desktop,
-        });
-        // When upgrading to video, remove the `stripVideo` modifiers
-        if (newConstraints && newConstraints.video) {
-            const modifiers = sipSession.sessionDescriptionHandlerModifiersReInvite;
-            sipSession.sessionDescriptionHandlerModifiersReInvite = modifiers.filter(modifier => modifier !== modifiers_1.stripVideo);
-        }
-        sipSession.sessionDescriptionHandlerOptionsReInvite = Object.assign(Object.assign({}, sipSession.sessionDescriptionHandlerOptionsReInvite), { conference,
-            audioOnly });
-        const { constraints, } = this.getMediaConfiguration(shouldDoVideo, conference, newConstraints);
-        return sipSession.invite({
-            requestDelegate: {
-                onAccept: (response) => {
-                    // Update the SDP body to be able to call sessionWantsToDoVideo correctly in `_setup[Local|Remote]Media`.
-                    // Can't set directly sipSession.body because it's a getter.
-                    // @ts-ignore: private
-                    if (sipSession instanceof api_1.Inviter && sipSession.outgoingRequestMessage.body) {
-                        // @ts-ignore: private
-                        sipSession.outgoingRequestMessage.body.body = response.message.body;
-                    }
-                    else if (sipSession instanceof api_1.Invitation) {
-                        // @ts-ignore: private
-                        sipSession.incomingInviteRequest.message.body = response.message.body;
-                    }
-                    logger.info('on re-INVITE accepted', {
-                        id: this.getSipSessionId(sipSession),
-                        wasMuted,
-                        shouldDoScreenSharing,
-                    });
-                    this.updateRemoteStream(this.getSipSessionId(sipSession), false);
-                    if (wasMuted) {
-                        this.mute(sipSession);
-                    }
-                    this._onAccepted(sipSession, response.session, false, false);
-                    if (shouldDoScreenSharing) {
-                        this.eventEmitter.emit(ON_SCREEN_SHARING_REINVITE, sipSession, response, desktop);
-                    }
-                    return this.eventEmitter.emit(ON_REINVITE, sipSession, response);
-                },
-            },
-            sessionDescriptionHandlerModifiers: [exports.replaceLocalIpModifier],
-            requestOptions: {
-                extraHeaders: [`Subject: ${shouldDoScreenSharing ? 'screenshare' : 'upgrade-video'}`],
-            },
-            sessionDescriptionHandlerOptions: {
-                constraints,
-                conference,
-                audioOnly,
-                offerOptions: {
-                    iceRestart,
-                },
-            },
-        });
-    }
-    getUserMedia(constraints) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const newConstraints = {
-                audio: this._getAudioConstraints(),
-                video: this._getVideoConstraints(constraints.video),
-            };
-            return navigator.mediaDevices.getUserMedia(newConstraints);
-        });
-    }
-    getPeerConnection(sessionId) {
-        const sipSession = this.sipSessions[sessionId];
-        if (!sipSession) {
-            return null;
-        }
-        return sipSession.sessionDescriptionHandler ? sipSession.sessionDescriptionHandler.peerConnection : null;
-    }
-    // Local streams
-    getLocalStream(sessionId) {
-        var _a;
-        const sipSession = this.sipSessions[sessionId];
-        return ((_a = sipSession === null || sipSession === void 0 ? void 0 : sipSession.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.localMediaStream) || null;
-    }
-    getLocalTracks(sessionId) {
-        const localStream = this.getLocalStream(sessionId);
-        if (!localStream) {
-            return [];
-        }
-        return localStream.getTracks();
-    }
-    hasLocalVideo(sessionId) {
-        return this.getLocalTracks(sessionId).some(this._isVideoTrack);
-    }
-    // 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');
-    }
-    getLocalVideoStream(sessionId) {
-        return this.hasLocalVideo(sessionId) ? this.getLocalStream(sessionId) : null;
-    }
-    // Remote streams
-    getRemoteStream(sessionId) {
-        var _a;
-        const sipSession = this.sipSessions[sessionId];
-        return ((_a = sipSession === null || sipSession === void 0 ? void 0 : sipSession.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.remoteMediaStream) || null;
-    }
-    getRemoteTracks(sessionId) {
-        const remoteStream = this.getRemoteStream(sessionId);
-        if (!remoteStream) {
-            return [];
-        }
-        return remoteStream.getTracks();
-    }
-    hasRemoteVideo(sessionId) {
-        return this.getRemoteTracks(sessionId).some(this._isVideoTrack);
-    }
-    // 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');
-    }
-    getRemoteVideoStream(sessionId) {
-        if (this.isVideoRemotelyHeld(sessionId)) {
-            return null;
-        }
-        return this.hasRemoteVideo(sessionId) ? this.getRemoteStream(sessionId) : null;
-    }
-    //  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);
-    }
-    hasVideo(sessionId) {
-        return this.hasLocalVideo(sessionId) || this.hasRemoteVideo(sessionId);
-    }
-    hasAVideoTrack(sessionId) {
-        return this.hasALocalVideoTrack(sessionId) || this.hasARemoteVideoTrack(sessionId);
-    }
-    getSipSessionId(sipSession) {
-        if (!sipSession) {
-            return '';
-        }
-        // For Inviter
-        // @ts-ignore: private
-        if (sipSession instanceof api_1.Inviter && sipSession.outgoingRequestMessage) {
-            // @ts-ignore: private
-            return sipSession.outgoingRequestMessage.callId;
-        }
-        // For Invitation
-        // @ts-ignore: private
-        if (sipSession instanceof api_1.Invitation && sipSession.incomingInviteRequest.message) {
-            // @ts-ignore: private
-            return sipSession.incomingInviteRequest.message.callId;
-        }
-        // For EarlyMedia
-        // @ts-ignore: private
-        if (sipSession instanceof session_dialog_1.SessionDialog) {
-            // @ts-ignore: private
-            return sipSession.dialogState.callId;
-        }
-        return '';
-    }
-    waitForRegister() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 (0, sdp_1.hasAnActiveVideo)(sdp);
-    }
-    hasHeartbeat() {
-        return this.heartbeat.hasHeartbeat;
-    }
-    startHeartbeat() {
-        logger.info('sdk webrtc start heartbeat', { userAgent: !!this.userAgent, clientId: this.clientId });
-        if (!this.userAgent) {
-            this.heartbeat.stop();
-            return;
-        }
-        this.eventEmitter.off(MESSAGE, this._boundOnHeartbeat);
-        this.eventEmitter.on(MESSAGE, this._boundOnHeartbeat);
-        this.heartbeat.start();
-    }
-    stopHeartbeat() {
-        logger.info('sdk webrtc stop heartbeat', { clientId: this.clientId });
-        this.heartbeat.stop();
-    }
-    setOnHeartbeatTimeout(cb) {
-        this.heartbeatTimeoutCb = cb;
-    }
-    setOnHeartbeatCallback(cb) {
-        this.heartbeatCb = cb;
-    }
-    onCallEnded(session) {
-        this._cleanupMedia(session);
-        delete this.sipSessions[this.getSipSessionId(session)];
-        this._stopSendingStats(session);
-        this.stopNetworkMonitoring(session);
-    }
-    attemptReconnection() {
-        logger.info('attempt reconnection', { clientId: this.clientId, userAgent: !!this.userAgent });
-        if (!this.userAgent) {
-            return;
-        }
-        // @ts-ignore: private
-        this.userAgent.attemptReconnection();
-    }
-    storeSipSession(session) {
-        const id = this.getSipSessionId(session);
-        logger.info('storing sip session', { id, clientId: this.clientId });
-        this.sipSessions[id] = session;
-    }
-    getSipSession(id) {
-        return id in this.sipSessions ? this.sipSessions[id] : null;
-    }
-    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;
-        }
-    }
-    updateLocalStream(sipSessionId, newStream) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sipSession = this.sipSessions[sipSessionId];
-            if (!sipSession) {
-                return;
-            }
-            const oldStream = this.getLocalStream(sipSessionId);
-            logger.info('updating local stream', {
-                sipSessionId,
-                oldStream: !!oldStream,
-                tracks: newStream.getTracks(),
-            });
-            if (oldStream) {
-                this._cleanupStream(oldStream);
-            }
-            this.setLocalMediaStream(sipSessionId, newStream);
-            // Update the local video element
-            yield 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: Object.assign({ 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;
-    }
-    createAudioElementFor(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const audio = document.createElement('audio');
-            audio.setAttribute('id', `audio-${sessionId}`);
-            logger.info('creating audio element', { sessionId, audioOutputDeviceId: this.audioOutputDeviceId });
-            if (this.audioOutputDeviceId) {
-                yield audio.setSinkId(this.audioOutputDeviceId);
-            }
-            if (document.body) {
-                document.body.appendChild(audio);
-            }
-            this.audioElements[sessionId] = audio;
-            audio.volume = this.audioOutputVolume;
-            audio.autoplay = true;
-            return audio;
-        });
-    }
-    _onTransportError() {
-        logger.error('on transport error');
-        this.eventEmitter.emit(TRANSPORT_ERROR);
-        this.attemptReconnection();
-    }
-    enableLogger(logConnector) {
-        var _a;
-        if (!this.userAgent) {
-            return;
-        }
-        if ((_a = this.userAgent) === null || _a === void 0 ? void 0 : _a.transport) {
-            this.userAgent.transport.configuration.traceSip = true;
-        }
-        // @ts-ignore: private
-        this.userAgent.loggerFactory.builtinEnabled = true;
-        // @ts-ignore: private
-        this.userAgent.loggerFactory.level = 3; // debug
-        // @ts-ignore: private
-        this.userAgent.loggerFactory.connector = logConnector;
-    }
-    _onHeartbeat(message) {
-        const body = message && typeof message === 'object' ? message.data : message;
-        if (body && body.indexOf('200 OK') !== -1) {
-            if (this.hasHeartbeat()) {
-                logger.info('on heartbeat received from Asterisk', {
-                    hasHeartbeat: this.hasHeartbeat(),
-                });
-                this.heartbeat.onHeartbeat();
-                if (this.heartbeatCb) {
-                    this.heartbeatCb();
-                }
-            }
-        }
-    }
-    _onHeartbeatTimeout() {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger.warn('sdk webrtc heartbeat timed out', {
-                userAgent: !!this.userAgent,
-                cb: !!this.heartbeatTimeoutCb,
-            });
-            if (this.heartbeatTimeoutCb) {
-                this.heartbeatTimeoutCb();
-            }
-            if (this.userAgent && this.userAgent.transport) {
-                // Disconnect from WS and triggers events, but do not trigger disconnect if already disconnecting...
-                const transport = this.userAgent.transport;
-                // @HEADS UP
-                if (!transport.transitioningState && !transport.disconnectPromise) {
-                    try {
-                        yield this.userAgent.transport.disconnect();
-                    }
-                    catch (e) {
-                        logger.error('Transport disconnection after heartbeat timeout, error', e);
-                    }
-                }
-                // We can invoke disconnect() with an error that can be catcher by `onDisconnect`, so we have to trigger it here.
-                this._onTransportError();
-            }
-        });
-    }
-    _isWeb() {
-        return typeof window === 'object' && typeof document === 'object';
-    }
-    _isVideoTrack(track) {
-        return track.kind === 'video' && track.readyState === 'live';
-    }
-    _hasAudio() {
-        return this.hasAudio;
-    }
-    _getAudioConstraints() {
-        var _a, _b;
-        // @ts-ignore: media constraints
-        return ((_b = (_a = this.audio) === null || _a === void 0 ? void 0 : _a.deviceId) === null || _b === void 0 ? void 0 : _b.exact) ? this.audio : true;
-    }
-    _getVideoConstraints(video = false) {
-        var _a, _b;
-        if (!video) {
-            return false;
-        }
-        // @ts-ignore: media constraints
-        return ((_b = (_a = this.video) === null || _a === void 0 ? void 0 : _a.deviceId) === null || _b === void 0 ? void 0 : _b.exact) ? this.video : true;
-    }
-    _connectIfNeeded() {
-        logger.info('connect if needed, checking', { connected: this.isConnected(), clientId: this.clientId });
-        if (!this.userAgent) {
-            logger.info('need to recreate User Agent');
-            this.userAgent = this.createUserAgent(this.uaConfigOverrides);
-        }
-        if (this.isConnected()) {
-            logger.info('webrtc sdk, already connected');
-            return Promise.resolve();
-        }
-        if (this.isConnecting()) {
-            logger.info('webrtc sdk, already connecting...');
-            this.connectionPromise = this.userAgent.transport.connectPromise;
-            return Promise.resolve(this.connectionPromise);
-        }
-        if (this.connectionPromise) {
-            logger.info('webrtc sdk, connection promise connecting...');
-            return this.connectionPromise;
-        }
-        logger.info('WebRTC UA needs to connect');
-        // Force UA to reconnect
-        if (this.userAgent && this.userAgent.state !== user_agent_state_1.UserAgentState.Stopped) {
-            // @ts-ignore: private
-            this.userAgent.transitionState(user_agent_state_1.UserAgentState.Stopped);
-        }
-        if (this.userAgent.transport && this.userAgent.transport.state !== transport_state_1.TransportState.Disconnected) {
-            this.userAgent.transport.transitionState(transport_state_1.TransportState.Disconnected);
-        }
-        this.connectionPromise = this.userAgent.start().catch(console.error);
-        return this.connectionPromise;
-    }
-    _buildConfig(config, session) {
-        // If no session provided, return the configuration directly
-        if (!session) {
-            return new Promise(resolve => resolve(config));
-        }
-        const client = new api_client_1.default({
-            server: `${config.host}:${String(config.port || 443)}`,
-        });
-        client.setToken(session.token);
-        client.setRefreshToken(session.refreshToken);
-        return client.confd.getUserLineSipFromToken(session.uuid).then(sipLine => (Object.assign({ authorizationUser: sipLine.username, password: sipLine.secret, uri: `${sipLine.username}@${config.host}` }, 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,
-            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 = Object.assign(Object.assign({}, options), { iceGatheringTimeout, peerConnectionConfiguration: Object.assign(Object.assign({}, (0, peer_connection_configuration_default_1.defaultPeerConnectionConfiguration)()), (options.peerConnectionConfiguration || {})) });
-                return new WazoSessionDescriptionHandler_1.default(uaLogger, WazoSessionDescriptionHandler_1.wazoMediaStreamFactory, sdhOptions, isWeb, session);
-            },
-            transportOptions: {
-                traceSip: (uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? void 0 : uaOptionsOverrides.traceSip) || false,
-                wsServers: `wss://${host}:${port}/api/asterisk/ws${userUuid ? `?userUuid=${userUuid}` : ''}`,
-            },
-            sessionDescriptionHandlerFactoryOptions: {
-                modifiers: [exports.replaceLocalIpModifier],
-                alwaysAcquireMediaFirst: this.isFirefox(),
-                constraints: {
-                    audio: this._getAudioConstraints(),
-                    video: this._getVideoConstraints(),
-                },
-                peerConnectionOptions: {
-                    iceCheckingTimeout: this.config.iceCheckingTimeout || 1000,
-                    iceGatheringTimeout: this.config.iceCheckingTimeout || 1000,
-                    rtcConfiguration: Object.assign(Object.assign({ rtcpMuxPolicy: 'require', iceServers: WebRTCClient.getIceServers(this.config.host) }, this._getRtcOptions()), ((uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? void 0 : uaOptionsOverrides.peerConnectionOptions) || {})),
-                },
-                // Configuration used in SDH to create the PeerConnection
-                peerConnectionConfiguration: Object.assign({ rtcpMuxPolicy: 'require', iceServers: WebRTCClient.getIceServers(this.config.host) }, ((uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? void 0 : uaOptionsOverrides.peerConnectionOptions) || {})),
-            },
-        };
-        uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? true : delete uaOptionsOverrides.traceSip;
-        return Object.assign(Object.assign({}, 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);
-        // 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);
-            });
-            sdh.peerConnectionDelegate = {
-                onicecandidateerror: (error) => {
-                    logger.error('on icecandidate error', {
-                        address: error.address,
-                        port: error.port,
-                        errorCode: error.errorCode,
-                        errorText: error.errorText,
-                        url: error.url,
-                    });
-                },
-            };
-        };
-        // @ts-ignore: protected
-        const oldInviteRequest = session.onInviteRequest.bind(session);
-        let hadRemoteVideo = false;
-        // Monkey patch `onInviteRequest` to be able to know if there was a remote video stream before `onInvite` is called
-        // Because when `onInvite` is called we already got the video track
-        // @ts-ignore: protected
-        session.onInviteRequest = request => {
-            hadRemoteVideo = this.hasARemoteVideoTrack(sipSessionId);
-            oldInviteRequest(request);
-        };
-        session.delegate.onInvite = (request) => __awaiter(this, void 0, void 0, function* () {
-            let updatedCalleeName = null;
-            let updatedNumber = null;
-            if (session.assertedIdentity) {
-                // @ts-ignore: private
-                updatedNumber = session.assertedIdentity.uri.normal.user;
-                updatedCalleeName = session.assertedIdentity.displayName || updatedNumber;
-            }
-            logger.info('re-invite received', {
-                updatedCalleeName,
-                updatedNumber,
-                hadRemoteVideo,
-            });
-            // Useful to know if it's a video upgrade or an unhold from a remote peer with a video stream
-            // Update SDP
-            // Remote video is handled by the `track` event. Here we're dealing with video stream removal.
-            if (session instanceof api_1.Invitation) {
-                // @ts-ignore: private
-                session.incomingInviteRequest.message.body = request.body;
-                // @ts-ignore: private
-            }
-            else if (session instanceof api_1.Inviter && session.outgoingInviteRequest.message.body) {
-                // @ts-ignore: private
-                session.outgoingInviteRequest.message.body.body = request.body;
-            }
-            this.updateRemoteStream(sipSessionId, false);
-            yield this._setupMedias(session);
-            return this.eventEmitter.emit(ON_REINVITE, session, request, updatedCalleeName, updatedNumber, hadRemoteVideo);
-        });
-    }
-    _onProgress(session_1) {
-        return __awaiter(this, arguments, void 0, function* (session, early = false) {
-            yield this._setupMedias(session);
-            const sessionId = this.getSipSessionId(session);
-            this.updateRemoteStream(sessionId);
-            logger.info('progress received', {
-                sessionId,
-                early,
-            });
-            this.eventEmitter.emit(early ? ON_EARLY_MEDIA : ON_PROGRESS, session);
-        });
-    }
-    _onAccepted(session_1, sessionDialog_1) {
-        return __awaiter(this, arguments, void 0, function* (session, sessionDialog, withEvent = true, initAllTracks = true) {
-            var _a;
-            logger.info('on call accepted', {
-                id: this.getSipSessionId(session),
-                clientId: this.clientId,
-                remoteTag: session.remoteTag,
-            });
-            this.storeSipSession(session);
-            yield this._setupMedias(session);
-            this.updateRemoteStream(this.getSipSessionId(session), initAllTracks);
-            const pc = (_a = session.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.peerConnection;
-            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,
-                });
-                // Stop video track in audio only mode
-                if (isAudioOnly && kind === 'video') {
-                    event.track.stop();
-                }
-                this.eventEmitter.emit(ON_TRACK, session, event);
-            };
-            const sessionDescriptionHandler = session.sessionDescriptionHandler;
-            if (sessionDescriptionHandler === null || sessionDescriptionHandler === void 0 ? void 0 : sessionDescriptionHandler.peerConnection) {
-                sessionDescriptionHandler.peerConnection.addEventListener('track', onTrack);
-            }
-            sessionDescriptionHandler.remoteMediaStream.onaddtrack = onTrack;
-            if (pc) {
-                pc.oniceconnectionstatechange = () => {
-                    logger.info('on ice connection state changed', {
-                        state: pc.iceConnectionState,
-                    });
-                    if (pc.iceConnectionState === 'disconnected') {
-                        this.eventEmitter.emit(ON_DISCONNECTED);
-                    }
-                };
-            }
-            if (withEvent) {
-                this.eventEmitter.emit(ACCEPTED, session, sessionDialog);
-            }
-            this._startSendingStats(session);
-        });
-    }
-    _isAudioOnly(session) {
-        return Boolean(session.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === modifiers_1.stripVideo));
-    }
-    _setupMedias(session_1) {
-        return __awaiter(this, arguments, void 0, function* (session, newStream = null) {
-            if (!this._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 isConference = this.isConference(sessionId);
-            if (sessionId in this.audioElements) {
-                logger.info('html element already exists for session', {
-                    sessionId,
-                });
-                return;
-            }
-            if (this._hasAudio() && this._isWeb() && !(sessionId in this.audioElements)) {
-                yield this.createAudioElementFor(sessionId);
-            }
-            const audioElement = this.audioElements[sessionId];
-            const sipSession = this.sipSessions[session.callId];
-            const removeStream = this.getRemoteStream(sessionId);
-            const sdh = sipSession === null || sipSession === void 0 ? void 0 : sipSession.sessionDescriptionHandler;
-            const earlyStream = sdh ? sdh.remoteMediaStream : null;
-            const stream = newStream || removeStream || earlyStream;
-            if (!stream) {
-                logger.info('Setup media no stream to attach, bailing');
-                return;
-            }
-            const shouldPause = audioElement.currentTime > 0 && !audioElement.paused && !audioElement.ended && audioElement.readyState > 2;
-            logger.info('setting up media', {
-                sessionId,
-                streams: {
-                    new: !!newStream,
-                    remove: !!removeStream,
-                    early: !!earlyStream,
-                },
-                hasAudio: this._hasAudio(),
-                isConference,
-                shouldPause,
-            });
-            if (isConference) {
-                // Conference local stream is handled in Room
-                return;
-            }
-            if (shouldPause) {
-                audioElement.pause();
-            }
-            audioElement.srcObject = stream;
-            audioElement.volume = this.audioOutputVolume;
-            audioElement.play().catch(() => { });
-        });
-    }
-    _cleanupMedia(session) {
-        const sessionId = this.getSipSessionId(session);
-        const localStream = this.getLocalStream(sessionId);
-        if (localStream) {
-            this._cleanupStream(localStream);
-        }
-        const cleanLocalElement = (id) => {
-            const element = this.audioElements[id];
-            if (!element) {
-                return;
-            }
-            element.pause();
-            if (element.parentNode) {
-                element.parentNode.removeChild(element);
-            }
-            element.srcObject = null;
-            delete this.audioElements[id];
-        };
-        if (this._hasAudio() && this._isWeb()) {
-            if (session) {
-                cleanLocalElement(this.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 === null || sdh === void 0 ? void 0 : 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 === null || sdh === void 0 ? void 0 : sdh.peerConnection;
-        if (pc === null || pc === void 0 ? void 0 : 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
-            this.registerer.stateChange.removeAllListeners();
-            this.registerer = null;
-        }
-    }
-    _startSendingStats(session) {
-        const sdh = session.sessionDescriptionHandler;
-        const pc = sdh.peerConnection;
-        if (!pc) {
-            return;
-        }
-        const sessionId = this.getSipSessionId(session);
-        (0, getstats_1.default)(pc, (result) => {
-            const { results, internal, nomore } = result, stats = __rest(result, ["results", "internal", "nomore"]);
-            this.statsIntervals[sessionId] = nomore;
-            statsLogger.trace('stats', Object.assign({ sessionId }, stats));
-        }, SEND_STATS_DELAY);
-    }
-    _stopSendingStats(session) {
-        const sessionId = this.getSipSessionId(session);
-        logger.trace('Check for stopping stats', {
-            sessionId,
-            ids: Object.keys(this.statsIntervals),
-        });
-        if (sessionId in this.statsIntervals) {
-            logger.trace('Stop sending stats for call', {
-                sessionId,
-            });
-            this.statsIntervals[sessionId]();
-            delete this.statsIntervals[sessionId];
-        }
-    }
-    _makeURI(target) {
-        return user_agent_1.UserAgent.makeURI(`sip:${target}@${this.config.host}`);
-    }
-    _disconnectTransport() {
-        return __awaiter(this, arguments, void 0, function* (force = false) {
-            var _a;
-            const transport = (_a = this.userAgent) === null || _a === void 0 ? void 0 : _a.transport;
-            if (force && transport) {
-                // Bypass sip.js state machine that prevent to close WS with the state `Connecting`
-                transport.disconnectResolve = () => { };
-                if (transport._ws) {
-                    transport._ws.close(1000);
-                }
-                return;
-            }
-            // Check if `disconnectPromise` is not present to avoid `Disconnect promise must not be defined` errors.
-            if (transport && !transport.disconnectPromise) {
-                try {
-                    yield transport.disconnect();
-                }
-                catch (e) {
-                    logger.error('WebRTC transport disconnect, error', e);
-                }
-            }
-        });
-    }
-    _fetchNetworkStats(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = this.getSipSession(sessionId);
-            const stats = session ? yield this.getStats(session) : null;
-            if (!stats || !(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;
-            if (this.sessionNetworkStats[sessionId]) {
-                this.eventEmitter.emit(ON_NETWORK_STATS, session, networkStats, this.sessionNetworkStats[sessionId]);
-                if (sessionId in this.sessionNetworkStats) {
-                    this.sessionNetworkStats[sessionId].push(networkStats);
-                }
-            }
-        });
-    }
-    _accept(session_1) {
-        return __awaiter(this, arguments, void 0, function* (session, options = {}) {
-            if (session.state === session_state_1.SessionState.Terminated || session.state === session_state_1.SessionState.Terminating) {
-                const error = 'Trying to accept a terminated sipSession.';
-                logger.warn(error, { state: session.state, sessionId: this.getSipSessionId(session) });
-                throw new Error(error);
-            }
-            if (session.state !== session_state_1.SessionState.Initial) {
-                const error = 'Trying to accept a non Initial sipSession.';
-                logger.warn(error, { state: session.state, sessionId: this.getSipSessionId(session) });
-                throw new Error(error);
-            }
-            // @ts-ignore: private
-            if (!session.incomingInviteRequest.acceptable) {
-                const error = 'Trying to reject a non `acceptable` session';
-                logger.warn(error, { state: session.state, sessionId: this.getSipSessionId(session) });
-                throw new Error(error);
-            }
-            try {
-                return yield session.accept(options);
-            }
-            catch (e) {
-                logger.warn('Session accept, error', e);
-            }
-        });
-    }
-    _reject(session_1) {
-        return __awaiter(this, arguments, void 0, function* (session, options = {}) {
-            if (session.state !== session_state_1.SessionState.Initial && session.state !== session_state_1.SessionState.Establishing) {
-                logger.warn('Trying to reject a session in a wrong state', { state: session.state, sessionId: this.getSipSessionId(session) });
-                return;
-            }
-            // @ts-ignore: private
-            if (!session.incomingInviteRequest.rejectable) {
-                logger.warn('Trying to reject a non `rejectable` session', { state: session.state, sessionId: this.getSipSessionId(session) });
-                return;
-            }
-            try {
-                return yield session.reject(options);
-            }
-            catch (e) {
-                logger.warn('Session reject, error', e);
-            }
-        });
-    }
-    _cancel(session_1) {
-        return __awaiter(this, arguments, void 0, function* (session, options = {}) {
-            if (session.state !== session_state_1.SessionState.Initial && session.state !== session_state_1.SessionState.Establishing) {
-                logger.warn('Trying to cancel a session in a wrong state', { state: session.state, sessionId: this.getSipSessionId(session) });
-                return;
-            }
-            try {
-                return yield session.cancel(options);
-            }
-            catch (e) {
-                logger.warn('Session cancel, error', e);
-            }
-        });
-    }
-    _bye(session_1) {
-        return __awaiter(this, arguments, void 0, function* (session, options = {}) {
-            if (session.state !== session_state_1.SessionState.Established) {
-                logger.warn('Trying to end a session in a wrong state', { state: session.state, sessionId: this.getSipSessionId(session) });
-                return null;
-            }
-            try {
-                return yield session.bye(options);
-            }
-            catch (e) {
-                logger.warn('Session bye, error', e);
-            }
-            return null;
-        });
-    }
-}
-exports.default = WebRTCClient;