@wazo/sdk 0.38.22 → 0.39.0-beta.2

package/esm/lib/WazoSessionDescriptionHandler.js

@@ -1,916 +1,432 @@
+/* global RTCSessionDescriptionInit, navigator */
 import EventEmitter from 'events';
 import { SessionDescriptionHandler } from 'sip.js/lib/platform/web/session-description-handler/session-description-handler';
-import 'sip.js/lib/platform/web/session-description-handler/session-description-handler-options';
-import moment from 'moment';
-import 'js-base64';
-import sdpParser from 'sdp-transform';
-
-/*       */
-/* global navigator */
-const isMobile = () => typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-
-/*       */
-
-IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
-
-// Use a function here to be able to mock it in tests
-const realFetch = () => {
-  if (typeof document !== 'undefined' && window.fetch) {
-    // Browser
-    return window.fetch;
-  }
-
-  if (isMobile()) {
-    // React native
-    return fetch;
-  }
-
-  // nodejs
-  // this package is disable for react-native in package.json because it requires nodejs modules
-  // Used to trick the optimizer to avoid requiring `node-fetch/lib/index` directly
-  // It causes to require it on browsers when delivered by a nodejs engine (cf: vitejs).
-  try {
-    // $FlowFixMe
-    return require(Math.random() >= 0 ? 'node-fetch/lib/index' : '');
-  } catch (e) {
-    return fetch;
-  }
-};
-
-/* global window */
-
-const TRACE = 'trace';
-const DEBUG = 'debug';
-const INFO = 'info';
-const LOG = 'log';
-const WARN = 'warn';
-const ERROR = 'error';
-const CONSOLE_METHODS = [INFO, LOG, WARN, ERROR];
-const LOG_LEVELS = [TRACE, DEBUG, INFO, LOG, WARN, ERROR];
-const CATEGORY_PREFIX = 'logger-category=';
-
-const MAX_REMOTE_RETRY = 100;
-
-const addLevelsTo = (instance        , withMethods = false) => {
-  instance.TRACE = TRACE;
-  instance.DEBUG = DEBUG;
-  instance.INFO = INFO;
-  instance.LOG = LOG;
-  instance.WARN = WARN;
-  instance.ERROR = ERROR;
-
-  if (withMethods) {
-    instance.trace = (...args) => instance.apply(null, [TRACE, ...args]);
-    instance.debug = (...args) => instance.apply(null, [DEBUG, ...args]);
-    instance.info = (...args) => instance.apply(null, [INFO, ...args]);
-    instance.log = (...args) => instance.apply(null, [LOG, ...args]);
-    instance.warn = (...args) => instance.apply(null, [WARN, ...args]);
-    instance.error = (...args) => instance.apply(null, [ERROR, ...args]);
-  }
-
-  return instance;
-};
-
-const safeStringify = (object        ) => {
-  const result = '{"message": "Not parsable JSON"}';
-  try {
-    return JSON.stringify(object);
-  } catch (e) {
-    // Nothing to do
-  }
-
-  return result;
-};
-
-class IssueReporter {
-                
-               
-              
-               
-                
-
-                            
-                   
-                                     
-
-                   
-                            
-                                
-                                  
-                       
-
-  constructor() {
-    addLevelsTo(this);
-
-    this.oldConsoleMethods = null;
-    this.enabled = false;
-    this.remoteClientConfiguration = null;
-    this.buffer = [];
-    this.bufferTimeout = null;
-    this._boundProcessBuffer = this._processBuffer.bind(this);
-    this._boundParseLoggerBody = this._parseLoggerBody.bind(this);
-    this._callback = null;
-  }
-
-  init() {
-    this._catchConsole();
-  }
-
-  setCallback(cb          ) {
-    this._callback = cb;
-  }
-
-  configureRemoteClient(configuration         = { tag: 'wazo-sdk', host: null, port: null, level: null, extra: {} }) {
-    this.remoteClientConfiguration = configuration;
-  }
-
-  enable() {
-    if (!this.oldConsoleMethods) {
-      this.init();
-    }
-
-    this.enabled = true;
-  }
-
-  disable() {
-    this.enabled = false;
-  }
-
-  loggerFor(category        )      {
-    const logger = (level        , ...args     ) => {
-      this.log.apply(this, [level, this._makeCategory(category), ...args]);
-    };
-
-    return addLevelsTo(logger, true);
-  }
-
-  removeSlashes(str        ) {
-    return str.replace(/"/g, "'").replace(/\\/g, '');
-  }
-
-  log(level        , ...args     ) {
-    if (!this.enabled) {
-      return;
-    }
-
-    // Handle category label
-    let category = null;
-    let skipSendToRemote = false;
-    let extra = {};
-    if (args[0].indexOf(CATEGORY_PREFIX) === 0) {
-      category = args[0].split('=')[1];
-      // eslint-disable-next-line no-param-reassign
-      args.splice(0, 1);
-    }
-
-    // Handle extra data as object for the last argument
-    const lastArg = args[args.length - 1];
-    if (lastArg && ((typeof lastArg === 'object' && Object.keys(lastArg).length) || lastArg instanceof Error)) {
-      if (lastArg instanceof Error) {
-        extra = {
-          errorMessage: lastArg.message,
-          errorStack: lastArg.stack,
-          errorType: lastArg.constructor.name,
-          skipSendToRemote: lastArg.skipSendToRemote,
-        };
-      } else {
-        extra = lastArg;
-      }
-      // eslint-disable-next-line no-param-reassign
-      args.splice(1, 1);
-    }
-
-    if (extra.skipSendToRemote) {
-      skipSendToRemote = true;
-      delete extra.skipSendToRemote;
-    }
-
-    const date = moment().format('YYYY-MM-DD HH:mm:ss.SSS');
-    const message = args.join(', ');
-    let consoleMessage = message;
-
-    if (Object.keys(extra).length) {
-      const parsedExtra = safeStringify(extra);
-      consoleMessage = `${consoleMessage} (${parsedExtra})`;
-    }
-
-    if (category) {
-      consoleMessage = `[${category}] ${consoleMessage}`;
-    }
-
-    // Log the message in the console anyway (but don't console.error on mobile)
-    const consoleLevel = isMobile() && level === 'error' ? WARN : level;
-
-    // eslint-disable-next-line
-    const oldMethod = this.oldConsoleMethods[consoleLevel] || this.oldConsoleMethods.log;
-    oldMethod.apply(oldMethod, [date, consoleMessage]);
-
-    if (this._callback) {
-      this._callback(level, consoleMessage);
-    }
-
-    if (!skipSendToRemote) {
-      this._sendToRemoteLogger(level, { date, message, category, ...extra });
+import IssueReporter from '../service/IssueReporter';
+import { addIcesInAllBundles, fixSdp, parseCandidate } from '../utils/sdp';
+const wazoLogger = IssueReporter ? IssueReporter.loggerFor('webrtc-sdh') : console;
+// Customized mediaStreamFactory allowing to send screensharing stream directory when upgrading
+export const wazoMediaStreamFactory = (constraints) => {
+    // @see sip.js/lib/platform/web/session-description-handler/media-stream-factory-default
+    if (!constraints.audio && !constraints.video) {
+        return Promise.resolve(new MediaStream());
     }
-  }
-
-  logRequest(url        , options        , response        , start      ) {
-    if (!this.enabled) {
-      return;
+    if (navigator.mediaDevices === undefined) {
+        return Promise.reject(new Error('Media devices not available in insecure contexts.'));
     }
-    const { status } = response;
-    const duration = new Date() - start;
-
-    let level = TRACE;
-    if (status >= 400 && status < 500) {
-      level = WARN;
-    } else if (status >= 500) {
-      level = ERROR;
+    // We have to make a `getUserMedia` on desktop but a `getDisplayMedia` in browsers when screensharing
+    if (constraints.screen && !constraints.desktop) {
+        return navigator.mediaDevices.getDisplayMedia.call(navigator.mediaDevices, constraints);
     }
-
-    this.log(level, this._makeCategory('http'), url, {
-      status,
-      body: this.removeSlashes(JSON.stringify(options.body)),
-      method: options.method,
-      headers: options.headers,
-      duration,
-    });
-  }
-
-  // Logs aren't stored anymore
-  getLogs() {
-    console.warn('IssueReporter\'s logs aren\'t stored anymore. Please use fluentd to store them');
-    return [];
-  }
-
-  getParsedLogs() {
-    console.warn('IssueReporter\'s logs aren\'t stored anymore. Please use fluentd to store them');
-    return [];
-  }
-
-  getReport() {
-    return this.getParsedLogs().join('\r\n');
-  }
-
-  _catchConsole() {
-    this.oldConsoleMethods = {};
-    CONSOLE_METHODS.forEach((methodName        ) => {
-      // eslint-disable-next-line
-      this.oldConsoleMethods[methodName] = console[methodName];
-      window.console[methodName] = (...args) => {
-        // Store message
+    return navigator.mediaDevices.getUserMedia.call(navigator.mediaDevices, constraints);
+};
+class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
+    gatheredCandidates;
+    eventEmitter;
+    isWeb;
+    session;
+    // eslint-disable-next-line @typescript-eslint/default-param-last
+    constructor(logger, mediaStreamFactory, sessionDescriptionHandlerConfiguration, isWeb, session) {
+        super(logger, mediaStreamFactory, sessionDescriptionHandlerConfiguration);
+        this.eventEmitter = new EventEmitter();
+        this.isWeb = isWeb;
+        this.session = session;
+    }
+    on(event, callback) {
+        this.eventEmitter.on(event, callback);
+    }
+    off(event, callback) {
+        this.eventEmitter.removeListener(event, callback);
+    }
+    setRemoteSessionDescription(sessionDescription) {
         try {
-          this.log(methodName, args.join(' '));
-          // Use old console method to log it normally
-          this.oldConsoleMethods[methodName].apply(null, args);
-        } catch (e) {
-          // Avoid circular structure issues
+            const result = super.setRemoteSessionDescription(sessionDescription);
+            this.eventEmitter.emit('setDescription', sessionDescription);
+            return result;
         }
-      };
-    });
-  }
-
-  _sendToRemoteLogger(level        , payload         = {}) {
-    if (!this.remoteClientConfiguration) {
-      return;
-    }
-
-    const { level: minLevel, bufferSize } = this.remoteClientConfiguration;
-    if (!minLevel || this._isLevelAbove(minLevel, level)) {
-      return;
-    }
-
-    payload.level = level;
-
-    if (bufferSize > 0) {
-      return this._addToBuffer(payload);
-    }
-
-    this._sendDebugToGrafana(payload);
-  }
-
-  _parseLoggerBody(payload        ) {
-    const { level } = payload;
-    const { maxMessageSize, extra } = this.remoteClientConfiguration || {};
-
-    delete payload.level;
-
-    if (maxMessageSize && typeof payload.message === 'string' && payload.message.length > maxMessageSize) {
-      payload.message = `${payload.message.substr(0, maxMessageSize)}...`;
-    }
-
-    return safeStringify({
-      level,
-      ...payload,
-      ...extra,
-    });
-  }
-
-  _addToBuffer(payload        ) {
-    // Reset buffer timer
-    if (this.bufferTimeout) {
-      clearTimeout(this.bufferTimeout);
-      this.bufferTimeout = null;
-    }
-
-    this.buffer.push(payload);
-
-    // $FlowFixMe
-    const { bufferSize, bufferTimeout } = this.remoteClientConfiguration;
-
-    if (this.buffer.length > bufferSize) {
-      return this._processBuffer();
-    }
-
-    if (bufferTimeout > 0) {
-      this.bufferTimeout = setTimeout(this._boundProcessBuffer, bufferTimeout);
-    }
-  }
-
-  _processBuffer() {
-    this._sendDebugToGrafana(this.buffer);
-
-    this.buffer = [];
-    if (this.bufferTimeout) {
-      clearTimeout(this.bufferTimeout);
-      this.bufferTimeout = null;
-    }
-  }
-
-  _sendDebugToGrafana(payload                   , retry         = 0) {
-    if (!this.remoteClientConfiguration || retry >= MAX_REMOTE_RETRY) {
-      return;
-    }
-
-    const { tag, host, port } = this.remoteClientConfiguration;
-    const isArray = Array.isArray(payload);
-    const isSecure = +port === 443;
-    const url = `http${isSecure ? 's' : ''}://${host}${isSecure ? '' : `:${port}`}/${tag}`;
-    const body = isArray ? `[${payload.map(this._boundParseLoggerBody).join(',')}]` : this._parseLoggerBody(payload);
-
-    realFetch()(url, {
-      method: 'POST',
-      headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-      },
-      // $FlowFixMe
-      body,
-    }).catch((e       ) => {
-      // $FlowFixMe
-      e.skipSendToRemote = true;
-      this.log('error', this._makeCategory('grafana'), 'Sending log to grafana, error', e);
-
-      setTimeout(() => {
-        if (isArray) {
-          payload = payload.map(message => this._writeRetryCount(message, retry + 1));
-        } else if (payload && typeof payload === 'object') {
-          payload = this._writeRetryCount(payload, retry + 1);
+        catch (error) {
+            this.logger.error(`SessionDescriptionHandler.setRemoteSessionDescription: ${error}`);
+            throw error;
         }
-
-        this._sendDebugToGrafana(payload, retry + 1);
-      }, 5000 + retry * 1000);
-    });
-  }
-
-  _writeRetryCount(message                 , count        )                  {
-    if (message && typeof message === 'object') {
-      // $FlowFixMe
-      message._retry = count;
-    }
-
-    return message;
-  }
-
-  _isLevelAbove(level1        , level2        ) {
-    const index1 = LOG_LEVELS.indexOf(level1);
-    const index2 = LOG_LEVELS.indexOf(level2);
-    if (index1 === -1 || index2 === -1) {
-      return false;
     }
-
-    return index1 > index2;
-  }
-
-  _makeCategory(category        ) {
-    return `${CATEGORY_PREFIX}${category}`;
-  }
-}
-
-var IssueReporter$1 = new IssueReporter();
-
-/*       */
-
-const parseCandidate = (candidate         )          => {
-  if (!candidate) {
-    return null;
-  }
-  const result = sdpParser.parse(candidate.indexOf('a=') === 0 ? candidate : `a=${candidate}`);
-
-  return result.candidates ? result.candidates[0] : null;
-};
-
-const getSrflxOrRelay = (candidates          )           =>
-  candidates
-    .filter(candidate => candidate && (candidate.type === 'srflx' || candidate.type === 'relay'));
-
-const fixSdp = (sdp        , candidates          , forcePort          = true)         => {
-  const parsedSdp = sdpParser.parse(sdp);
-  const mainCandidate = getSrflxOrRelay(candidates)[0];
-  const ip = mainCandidate ? mainCandidate.ip : null;
-
-  if (ip) {
-    parsedSdp.origin.address = ip;
-  }
-
-  parsedSdp.media = parsedSdp.media.map(media => {
-    const port = forcePort ? (mainCandidate ? mainCandidate.port : media.port) : media.port;
-    return {
-      ...media,
-      port,
-      candidates: (media.candidates || []).concat(candidates),
-      direction: port < 10 ? 'inactive' : media.direction,
-    };
-  });
-
-  let fixed = sdpParser.write(parsedSdp);
-
-  if (ip) {
-    fixed = fixed.replace(/IN IP4 0.0.0.0/g, `IN IP4 ${ip}`);
-  }
-
-  return fixed;
-};
-
-const addIcesInAllBundles = (sdp        ) => {
-  const parsedSdp = sdpParser.parse(sdp);
-
-  const mediaWithCandidate = parsedSdp.media.find(media => !!media.candidates);
-  if (!mediaWithCandidate) {
-    return sdp;
-  }
-
-  const { candidates } = mediaWithCandidate;
-
-  parsedSdp.media = parsedSdp.media.map(media => ({
-    ...media,
-    candidates: media.candidates || candidates,
-  }));
-
-  return sdpParser.write(parsedSdp);
-};
-
-/* global RTCSessionDescriptionInit, navigator */
-
-const wazoLogger = IssueReporter$1 ? IssueReporter$1.loggerFor('webrtc-sdh') : console;
-
-// Customized mediaStreamFactory allowing to send screensharing stream directory when upgrading
-const wazoMediaStreamFactory = (constraints        )                       => {
-  // @see sip.js/lib/platform/web/session-description-handler/media-stream-factory-default
-  if (!constraints.audio && !constraints.video) {
-    return Promise.resolve(new MediaStream());
-  }
-
-  if (navigator.mediaDevices === undefined) {
-    return Promise.reject(new Error('Media devices not available in insecure contexts.'));
-  }
-
-  // We have to make a `getUserMedia` on desktop but a `getDisplayMedia` in browsers when screensharing
-  if (constraints.screen && !constraints.desktop) {
-    return navigator.mediaDevices.getDisplayMedia.call(navigator.mediaDevices, constraints);
-  }
-
-  return navigator.mediaDevices.getUserMedia.call(navigator.mediaDevices, constraints);
-};
-
-class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
-                                     
-
-  constructor(
-    logger        ,
-    mediaStreamFactory                    ,
-    sessionDescriptionHandlerConfiguration                                         ,
-    isWeb         ,
-    session         ,
-  ) {
-    super(logger, mediaStreamFactory, sessionDescriptionHandlerConfiguration);
-
-    this.eventEmitter = new EventEmitter();
-    this.isWeb = isWeb;
-    this.session = session;
-  }
-
-  on(event        , callback          ) {
-    this.eventEmitter.on(event, callback);
-  }
-
-  off(event        , callback          ) {
-    this.eventEmitter.removeListener(event, callback);
-  }
-
-  // $FlowFixMe
-  setRemoteSessionDescription(sessionDescription                           )                {
-    try {
-      const result = super.setRemoteSessionDescription(sessionDescription);
-
-      this.eventEmitter.emit('setDescription', sessionDescription);
-
-      return result;
-    } catch (error) {
-      this.logger.error('SessionDescriptionHandler.setRemoteSessionDescription error', error);
-      throw error;
-    }
-  }
-
-  // Overridden to avoid to fix ice-candidates missing in the SDP in react-native and chrome canary.
-  getDescription(options          = {}, modifiers                  )               {
-    this.logger.debug('SessionDescriptionHandler.getDescription');
-    if (this._peerConnection === undefined) {
-      return Promise.reject(new Error('Peer connection closed.'));
-    }
-    // Callback on data channel creation
-    this.onDataChannel = options.onDataChannel;
-
-    // ICE will restart upon applying an offer created with the iceRestart option
-    const iceRestart = options.offerOptions ? options.offerOptions.iceRestart : false;
-
-    const isConference = options ? !!options.conference : false;
-    const audioOnly = options ? !!options.audioOnly : false;
-
-    // We should wait for ice when iceRestart (reinvite) or for the first invite
-    // We shouldn't wait for ice when holding or resuming the call
-    // We shouldn't wait for ice when receiving a reinvite (eg: pendingReinviteAck = true)
-    const shouldWaitForIce = !this.session.pendingReinviteAck && (iceRestart || ('constraints' in options));
-
-    // ICE gathering timeout may be set on a per call basis, otherwise the configured default is used
-    const iceTimeout = options.iceGatheringTimeout === undefined
-      ? this.sessionDescriptionHandlerConfiguration.iceGatheringTimeout
-      : options.iceGatheringTimeout;
-
-    wazoLogger.trace('getting SDP description', { iceRestart, shouldWaitForIce, iceTimeout });
-
-    // Fetch ice ourselves for re-invite
-    this.gatheredCandidates = [];
-    if (!this.peerConnectionDelegate) {
-      this.peerConnectionDelegate = {};
-    }
-    this.peerConnectionDelegate.onicecandidate = event => {
-      wazoLogger.trace('onicecandidate', event.candidate ? event.candidate.candidate : { done: true });
-      if (event.candidate) {
-        this.gatheredCandidates.push(parseCandidate(event.candidate.candidate));
-
-        // When receiving a `srflx` or a `relay` candidate, consider the negotiation done.
-        if (event.candidate.candidate.indexOf('srflx') !== -1 || event.candidate.candidate.indexOf('relay') !== -1) {
-          wazoLogger.info('A valid ice was found, triggering ice gathering complete callback.', {
-            ice: event.candidate.candidate,
-          });
-          this.iceGatheringComplete();
+    // Overridden to avoid to fix ice-candidates missing in the SDP in react-native and chrome canary.
+    getDescription(options = {}, modifiers) {
+        this.logger.debug('SessionDescriptionHandler.getDescription');
+        if (this._peerConnection === undefined) {
+            return Promise.reject(new Error('Peer connection closed.'));
         }
-      }
-    };
-
-    return this.getLocalMediaStream(options)
-      .then(() => this.updateDirection(options, isConference, audioOnly))
-      .then(() => this.createDataChannel(options))
-      .then(() => {
-        if (isConference && (options.constraints && !options.constraints.video) && !('hold' in options) && !audioOnly) {
-          // Add a video an empty bundle to be able to replaceTrack when joining a conference without video
-          if (this.peerConnection.addTransceiver) {
-            this.peerConnection.addTransceiver('video', { streams: [this._localMediaStream], direction: 'sendrecv' });
-          }
-        }
-      })
-      .then(() => this.createLocalOfferOrAnswer(options))
-      .then(sessionDescription => this.setLocalSessionDescription(sessionDescription))
-      .then(() => this.waitForIceGatheringComplete(iceRestart, iceTimeout))
-      .then(() => this.getLocalSessionDescription())
-      .then(description => {
-        const { sdp } = description;
-
-        // Check if we got ICEs
-        if (sdp.indexOf('a=candidate') !== -1) {
-          return {
-            type: description.type,
-            sdp: addIcesInAllBundles(sdp),
-          };
+        // Callback on data channel creation
+        // @ts-ignore
+        this.onDataChannel = options.onDataChannel;
+        // ICE will restart upon applying an offer created with the iceRestart option
+        const iceRestart = options.offerOptions ? options.offerOptions.iceRestart : false;
+        const isConference = options ? !!options.conference : false;
+        const audioOnly = options ? !!options.audioOnly : false;
+        // We should wait for ice when iceRestart (reinvite) or for the first invite
+        // We shouldn't wait for ice when holding or resuming the call
+        // We shouldn't wait for ice when receiving a reinvite (eg: pendingReinviteAck = true)
+        // @ts-ignore
+        const shouldWaitForIce = !this.session.pendingReinviteAck && (iceRestart || 'constraints' in options);
+        // ICE gathering timeout may be set on a per call basis, otherwise the configured default is used
+        const iceTimeout = options.iceGatheringTimeout === undefined ? this.sessionDescriptionHandlerConfiguration?.iceGatheringTimeout : options.iceGatheringTimeout;
+        wazoLogger.trace('getting SDP description', {
+            iceRestart,
+            shouldWaitForIce,
+            iceTimeout,
+        });
+        // Fetch ice ourselves for re-invite
+        this.gatheredCandidates = [];
+        if (!this.peerConnectionDelegate) {
+            this.peerConnectionDelegate = {};
         }
-
-        wazoLogger.info('No ICE candidates found in SDP, fixing it with gathered ices', this.gatheredCandidates);
-
-        // @TODO: find a better way to set sdp in answer.
-        //  We can't call createAnswer again, so we have to put candidates manually with fixSdp
-        // In reinvite, createOffer doesn't update the SDP
-        return {
-          type: description.type,
-          // Fix sdp only when no candidates
-          sdp: fixSdp(sdp, this.gatheredCandidates, options && options.constraints ? options.constraints.video : false),
-        };
-      })
-      .then((sessionDescription) => this.applyModifiers(sessionDescription, modifiers))
-      .then((sessionDescription) => ({ body: sessionDescription.sdp, contentType: 'application/sdp' }))
-      .catch((error) => {
-        wazoLogger.error('error when creating media', error);
-        this.logger.error(`SessionDescriptionHandler.getDescription failed - ${error}`);
-        throw error;
-      });
-  }
-
-  // Overridden to avoid to use peerConnection.getReceivers and peerConnection.getSenders in react-native
-  sendDtmf(tones        , options                                             = {})          {
-    if (this.isWeb) {
-      return super.sendDtmf(tones, options);
-    }
-
-    this.logger.debug(`DTMF sent via INFO: ${tones.toString()}`);
-
-    const body = {
-      contentDisposition: 'render',
-      contentType: 'application/dtmf-relay',
-      content: `Signal=${tones}\r\nDuration=${options.duration || 1000}`,
-    };
-    const requestOptions = { body };
-
-    return this.session.info({ requestOptions });
-  }
-
-  // Overridden to avoid to use peerConnection.getReceivers and peerConnection.getSenders in react-native
-  close()       {
-    wazoLogger.info('closing sdh');
-
-    if (this.isWeb) {
-      return super.close();
-    }
-
-    // react-native
-    this.logger.debug('SessionDescriptionHandler.close');
-    if (this._peerConnection === undefined) {
-      return;
-    }
-
-    // Closing senders via getLocalStreams
-    this.peerConnection.getLocalStreams().forEach(stream => {
-      stream.getTracks().forEach((track) => {
-        track.stop();
-      });
-    });
-
-    // Closing receivers via getRemoteStreams
-    this.peerConnection.getRemoteStreams().forEach(stream => {
-      stream.getTracks().forEach(track => {
-        track.stop();
-      });
-    });
-
-    if (this._dataChannel) {
-      this._dataChannel.close();
-    }
-    this._peerConnection.close();
-    this._peerConnection = undefined;
-  }
-
-  // Overridden to send `inactive` in conference
-  updateDirection(options                                   , isConference          = false,
-    audioOnly          = false)                {
-    if (this._peerConnection === undefined) {
-      return Promise.reject(new Error('Peer connection closed.'));
-    }
-
-    // Waiting for `getTransceivers` API on mobile
-    if (!this.isWeb) {
-      return Promise.resolve();
-    }
-
-    switch (this._peerConnection.signalingState) {
-      case 'stable': {
-        // if we are stable, assume we are creating a local offer
-        this.logger.debug('SessionDescriptionHandler.updateDirection - setting offer direction');
-        // determine the direction to offer given the current direction and hold state
-        const directionToOffer = (currentDirection        , transceiver         /* RTCRtpTransceiver */)         => {
-          if (isConference) {
-            if (audioOnly && transceiver.receiver.track && transceiver.receiver.track.kind === 'video') {
-              return 'sendonly';
+        this.peerConnectionDelegate.onicecandidate = event => {
+            wazoLogger.trace('onicecandidate', event.candidate ? event.candidate.candidate : {
+                done: true,
+            });
+            if (event.candidate) {
+                // @ts-ignore @REEVALUATE
+                this.gatheredCandidates.push(parseCandidate(event.candidate.candidate));
+                // When receiving a `srflx` or a `relay` candidate, consider the negotiation done.
+                if (event.candidate.candidate.indexOf('srflx') !== -1 || event.candidate.candidate.indexOf('relay') !== -1) {
+                    wazoLogger.info('A valid ice was found, triggering ice gathering complete callback.', {
+                        ice: event.candidate.candidate,
+                    });
+                    this.iceGatheringComplete();
+                }
             }
-            return options && options.hold ? 'sendonly' : 'sendrecv';
-          }
-
-          switch (currentDirection) {
-            case 'inactive':
-              return options && options.hold ? 'inactive' : (isConference && !audioOnly ? 'sendrecv' : 'recvonly');
-            case 'recvonly':
-              return options && options.hold ? 'inactive' : 'recvonly';
-            case 'sendonly':
-              return options && options.hold ? 'sendonly' : 'sendrecv';
-            case 'sendrecv':
-              return options && options.hold ? 'sendonly' : 'sendrecv';
-            case 'stopped':
-              return 'stopped';
-            default:
-              throw new Error('Should never happen');
-          }
         };
-        // set the transceiver direction to the offer direction
-        this._peerConnection.getTransceivers().forEach((transceiver) => {
-          if (transceiver.direction /* guarding, but should always be true */) {
-            const offerDirection = directionToOffer(transceiver.direction, transceiver);
-            if (transceiver.direction !== offerDirection) {
-              // eslint-disable-next-line no-param-reassign
-              transceiver.direction = offerDirection;
+        return this.getLocalMediaStream(options).then(() => this.updateDirection(options, isConference, audioOnly)).then(() => this.createDataChannel(options)).then(() => {
+            if (isConference && options.constraints && !options.constraints.video && !('hold' in options) && !audioOnly) {
+                // Add a video an empty bundle to be able to replaceTrack when joining a conference without video
+                if (this.peerConnection?.addTransceiver) {
+                    this.peerConnection.addTransceiver('video', {
+                        streams: [this._localMediaStream],
+                        direction: 'sendrecv',
+                    });
+                }
             }
-          }
-        });
-      }
-        break;
-      case 'have-remote-offer': {
-        // if we have a remote offer, assume we are creating a local answer
-        this.logger.debug('SessionDescriptionHandler.updateDirection - setting answer direction');
-
-        // FIXME: This is not the correct way to determine the answer direction as it is only
-        // considering first match in the offered SDP and using that to determine the answer direction.
-        // While that may be fine for our current use cases, it is not a generally correct approach.
-        // determine the offered direction
-        const offeredDirection = (()                                                    => {
-          const description = this._peerConnection.remoteDescription;
-          if (!description) {
-            throw new Error('Failed to read remote offer');
-          }
-          const searchResult = /a=sendrecv\r\n|a=sendonly\r\n|a=recvonly\r\n|a=inactive\r\n/.exec(description.sdp);
-          if (searchResult) {
-            switch (searchResult[0]) {
-              case 'a=inactive\r\n':
-                return 'inactive';
-              case 'a=recvonly\r\n':
-                return 'recvonly';
-              case 'a=sendonly\r\n':
-                return 'sendonly';
-              case 'a=sendrecv\r\n':
-                return 'sendrecv';
-              default:
-                throw new Error('Should never happen');
+        })
+            .then(() => this.createLocalOfferOrAnswer(options))
+            .then((sessionDescription) => this.setLocalSessionDescription(sessionDescription))
+            .then(() => this.waitForIceGatheringComplete(iceRestart, iceTimeout))
+            .then(() => this.getLocalSessionDescription())
+            .then((description) => {
+            const { sdp, } = description;
+            // Check if we got ICEs
+            if (sdp.indexOf('a=candidate') !== -1) {
+                return {
+                    type: description.type,
+                    sdp: addIcesInAllBundles(sdp),
+                };
             }
-          }
-          return 'sendrecv';
-        })();
-
-        // determine the answer direction based on the offered direction and our hold state
-        const answerDirection = (()                                                    => {
-          switch (offeredDirection) {
-            case 'inactive':
-              return 'inactive';
-            case 'recvonly':
-              return 'sendonly';
-            case 'sendonly':
-              return options && options.hold ? 'inactive' : 'recvonly';
-            case 'sendrecv':
-              return options && options.hold ? 'sendonly' : 'sendrecv';
-            default:
-              throw new Error('Should never happen');
-          }
-        })();
-
-        // set the transceiver direction to the answer direction
-        this._peerConnection.getTransceivers().forEach((transceiver) => {
-          if (transceiver.stopped) {
+            wazoLogger.info('No ICE candidates found in SDP, fixing it with gathered ices', this.gatheredCandidates);
+            // @TODO: find a better way to set sdp in answer.
+            //  We can't call createAnswer again, so we have to put candidates manually with fixSdp
+            // In reinvite, createOffer doesn't update the SDP
+            return {
+                type: description.type,
+                // Fix sdp only when no candidates
+                // @ts-ignore
+                sdp: fixSdp(sdp, this.gatheredCandidates, options && options.constraints ? options.constraints.video : false),
+            };
+        })
+            .then((sessionDescription) => this.applyModifiers(sessionDescription, modifiers))
+            .then((sessionDescription) => ({
+            body: sessionDescription.sdp,
+            contentType: 'application/sdp',
+        }))
+            .catch((error) => {
+            wazoLogger.error('error when creating media', error);
+            this.logger.error(`SessionDescriptionHandler.getDescription failed - ${error}`);
+            throw error;
+        });
+    }
+    // Overridden to avoid to use peerConnection.getReceivers and peerConnection.getSenders in react-native
+    sendDtmf(tones, options = { duration: 0, interToneGap: 0 }) {
+        if (this.isWeb) {
+            return super.sendDtmf(tones, options);
+        }
+        this.logger.debug(`DTMF sent via INFO: ${tones.toString()}`);
+        const body = {
+            contentDisposition: 'render',
+            contentType: 'application/dtmf-relay',
+            content: `Signal=${tones}\r\nDuration=${options.duration || 1000}`,
+        };
+        const requestOptions = {
+            body,
+        };
+        // @ts-ignore @REEVALUATE: session.info is asynched
+        return this.session.info({
+            requestOptions,
+        });
+    }
+    // Overridden to avoid to use peerConnection.getReceivers and peerConnection.getSenders in react-native
+    close() {
+        wazoLogger.info('closing sdh');
+        if (this.isWeb) {
+            return super.close();
+        }
+        // react-native
+        this.logger.debug('SessionDescriptionHandler.close');
+        if (this._peerConnection === undefined) {
             return;
-          }
-          if (transceiver.direction /* guarding, but should always be true */) {
-            const { receiver } = transceiver;
-            if (isConference && audioOnly && receiver.track && receiver.track.kind === 'video') {
-              // eslint-disable-next-line no-param-reassign
-              transceiver.direction = 'inactive';
-              return;
-            }
-
-            if (transceiver.direction !== 'stopped' && transceiver.direction !== answerDirection) {
-              // eslint-disable-next-line no-param-reassign
-              transceiver.direction = answerDirection;
-            }
-          }
+        }
+        // Closing senders via getLocalStreams
+        // @ts-ignore
+        this.peerConnection?.getLocalStreams().forEach(stream => {
+            stream.getTracks().forEach((track) => {
+                track.stop();
+            });
+        });
+        // Closing receivers via getRemoteStreams
+        // @ts-ignore
+        this.peerConnection?.getRemoteStreams().forEach(stream => {
+            stream.getTracks().forEach((track) => {
+                track.stop();
+            });
         });
-      }
-        break;
-      case 'have-local-offer':
-      case 'have-local-pranswer':
-      case 'have-remote-pranswer':
-      case 'closed':
-      default:
-        return Promise.reject(new Error(`Invalid signaling state ${this._peerConnection.signalingState}`));
+        if (this._dataChannel) {
+            this._dataChannel.close();
+        }
+        this._peerConnection.close();
+        this._peerConnection = undefined;
     }
-    return Promise.resolve();
-  }
-
-  // Overridden to not reuse video track in SFU mode
-  setLocalMediaStream(stream             ) {
-    this.logger.debug('SessionDescriptionHandler.setLocalMediaStream');
-
-    if (!this._peerConnection) {
-      throw new Error('Peer connection undefined.');
+    // Overridden to send `inactive` in conference
+    updateDirection(options, isConference = false, audioOnly = false) {
+        if (this._peerConnection === undefined) {
+            return Promise.reject(new Error('Peer connection closed.'));
+        }
+        // Waiting for `getTransceivers` API on mobile
+        if (!this.isWeb) {
+            return Promise.resolve();
+        }
+        switch (this._peerConnection.signalingState) {
+            case 'stable':
+                {
+                    // if we are stable, assume we are creating a local offer
+                    this.logger.debug('SessionDescriptionHandler.updateDirection - setting offer direction');
+                    // determine the direction to offer given the current direction and hold state
+                    const directionToOffer = (currentDirection, transceiver) => {
+                        if (isConference) {
+                            if (audioOnly && transceiver.receiver.track && transceiver.receiver.track.kind === 'video') {
+                                return 'sendonly';
+                            }
+                            return options && options.hold ? 'sendonly' : 'sendrecv';
+                        }
+                        switch (currentDirection) {
+                            case 'inactive':
+                                return options && options.hold ? 'inactive' : isConference && !audioOnly ? 'sendrecv' : 'recvonly';
+                            case 'recvonly':
+                                return options && options.hold ? 'inactive' : 'recvonly';
+                            case 'sendonly':
+                                return options && options.hold ? 'sendonly' : 'sendrecv';
+                            case 'sendrecv':
+                                return options && options.hold ? 'sendonly' : 'sendrecv';
+                            case 'stopped':
+                                return 'stopped';
+                            default:
+                                throw new Error('Should never happen');
+                        }
+                    };
+                    // set the transceiver direction to the offer direction
+                    this._peerConnection.getTransceivers().forEach(transceiver => {
+                        if (transceiver.direction
+                        /* guarding, but should always be true */
+                        ) {
+                            const offerDirection = directionToOffer(transceiver.direction, transceiver);
+                            if (transceiver.direction !== offerDirection) {
+                                // @ts-ignore - @REEVALUATE
+                                // eslint-disable-next-line no-param-reassign
+                                transceiver.direction = offerDirection;
+                            }
+                        }
+                    });
+                }
+                break;
+            case 'have-remote-offer':
+                {
+                    // if we have a remote offer, assume we are creating a local answer
+                    this.logger.debug('SessionDescriptionHandler.updateDirection - setting answer direction');
+                    // FIXME: This is not the correct way to determine the answer direction as it is only
+                    // considering first match in the offered SDP and using that to determine the answer direction.
+                    // While that may be fine for our current use cases, it is not a generally correct approach.
+                    // determine the offered direction
+                    const offeredDirection = (() => {
+                        const description = this._peerConnection.remoteDescription;
+                        if (!description) {
+                            throw new Error('Failed to read remote offer');
+                        }
+                        const searchResult = /a=sendrecv\r\n|a=sendonly\r\n|a=recvonly\r\n|a=inactive\r\n/.exec(description.sdp);
+                        if (searchResult) {
+                            switch (searchResult[0]) {
+                                case 'a=inactive\r\n':
+                                    return 'inactive';
+                                case 'a=recvonly\r\n':
+                                    return 'recvonly';
+                                case 'a=sendonly\r\n':
+                                    return 'sendonly';
+                                case 'a=sendrecv\r\n':
+                                    return 'sendrecv';
+                                default:
+                                    throw new Error('Should never happen');
+                            }
+                        }
+                        return 'sendrecv';
+                    })();
+                    // determine the answer direction based on the offered direction and our hold state
+                    const answerDirection = (() => {
+                        switch (offeredDirection) {
+                            case 'inactive':
+                                return 'inactive';
+                            case 'recvonly':
+                                return 'sendonly';
+                            case 'sendonly':
+                                return options && options.hold ? 'inactive' : 'recvonly';
+                            case 'sendrecv':
+                                return options && options.hold ? 'sendonly' : 'sendrecv';
+                            default:
+                                throw new Error('Should never happen');
+                        }
+                    })();
+                    // set the transceiver direction to the answer direction
+                    this._peerConnection.getTransceivers().forEach(transceiver => {
+                        // @ts-ignore
+                        if (transceiver.stopped) {
+                            return;
+                        }
+                        if (transceiver.direction
+                        /* guarding, but should always be true */
+                        ) {
+                            const { receiver, } = transceiver;
+                            if (isConference && audioOnly && receiver.track && receiver.track.kind === 'video') {
+                                // eslint-disable-next-line no-param-reassign
+                                transceiver.direction = 'inactive';
+                                return;
+                            }
+                            if (transceiver.direction !== 'stopped' && transceiver.direction !== answerDirection) {
+                                // eslint-disable-next-line no-param-reassign
+                                transceiver.direction = answerDirection;
+                            }
+                        }
+                    });
+                }
+                break;
+            case 'have-local-offer':
+            case 'have-local-pranswer':
+            case 'have-remote-pranswer':
+            case 'closed':
+            default:
+                return Promise.reject(new Error(`Invalid signaling state ${this._peerConnection.signalingState}`));
+        }
+        return Promise.resolve();
     }
-    const pc = this._peerConnection;
-    const { sfu } = pc;
-    const localStream = this._localMediaStream;
-
-    const trackUpdates                       = [];
-
-    const updateTrack = (newTrack                  )       => {
-      const { kind } = newTrack;
-      if (kind !== 'audio' && kind !== 'video') {
-        throw new Error(`Unknown new track kind ${kind}.`);
-      }
-      const sender = pc.getSenders && pc.getSenders().find((otherSender) =>
-        otherSender.track && otherSender.track.kind === kind);
-
-      // Do not reuse sender video tracks in SFU
-      if (sender && (!sfu || newTrack.kind === 'audio')) {
-        if (sender.track) {
-          // eslint-disable-next-line no-param-reassign
-          newTrack.enabled = sender.track.enabled;
+    // Overridden to not reuse video track in SFU mode
+    setLocalMediaStream(stream) {
+        this.logger.debug('SessionDescriptionHandler.setLocalMediaStream');
+        if (!this._peerConnection) {
+            throw new Error('Peer connection undefined.');
         }
-        trackUpdates.push(
-          new Promise((resolve) => {
-            this.logger.debug(`SessionDescriptionHandler.setLocalMediaStream - replacing sender ${kind} track`);
-            resolve();
-          }).then(() =>
-            sender
-              .replaceTrack(newTrack)
-              .then(() => {
-                const oldTrack = localStream.getTracks().find((localTrack) => localTrack.kind === kind);
-                if (oldTrack) {
-                  oldTrack.stop();
-                  localStream.removeTrack(oldTrack);
-                  SessionDescriptionHandler.dispatchRemoveTrackEvent(localStream, oldTrack);
+        const pc = this._peerConnection;
+        const { sfu, } = pc;
+        const localStream = this._localMediaStream;
+        const trackUpdates = [];
+        const updateTrack = (newTrack) => {
+            const { kind, } = newTrack;
+            if (kind !== 'audio' && kind !== 'video') {
+                throw new Error(`Unknown new track kind ${kind}.`);
+            }
+            const sender = pc.getSenders && pc.getSenders().find((otherSender) => otherSender.track && otherSender.track.kind === kind);
+            // Do not reuse sender video tracks in SFU
+            if (sender && (!sfu || newTrack.kind === 'audio')) {
+                if (sender.track) {
+                    // eslint-disable-next-line no-param-reassign
+                    newTrack.enabled = sender.track.enabled;
                 }
-                localStream.addTrack(newTrack);
-                SessionDescriptionHandler.dispatchAddTrackEvent(localStream, newTrack);
-              })
-              .catch((error       ) => {
-                this.logger.error(
-                  `SessionDescriptionHandler.setLocalMediaStream - failed to replace sender ${kind} track`,
-                );
-                throw error;
-              })),
-        );
-      } else {
-        trackUpdates.push(
-          new Promise((resolve) => {
-            this.logger.debug(`SessionDescriptionHandler.setLocalMediaStream - adding sender ${kind} track`);
-            resolve();
-          }).then(() => {
-            // Review: could make streamless tracks a configurable option?
-            // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/addTrack#Usage_notes
-            try {
-              if (pc.addTrack) {
-                pc.addTrack(newTrack, localStream);
-              } else {
-                pc.addStream(localStream);
-              }
-            } catch (error) {
-              this.logger.error(`SessionDescriptionHandler.setLocalMediaStream - failed to add sender ${kind} track`);
-              throw error;
+                trackUpdates.push(new Promise(resolve => {
+                    this.logger.debug(`SessionDescriptionHandler.setLocalMediaStream - replacing sender ${kind} track`);
+                    resolve(null);
+                }).then(() => sender.replaceTrack(newTrack).then(() => {
+                    const oldTrack = localStream.getTracks().find(localTrack => localTrack.kind === kind);
+                    if (oldTrack) {
+                        oldTrack.stop();
+                        localStream.removeTrack(oldTrack);
+                        // @ts-ignore
+                        SessionDescriptionHandler.dispatchRemoveTrackEvent(localStream, oldTrack);
+                    }
+                    localStream.addTrack(newTrack);
+                    // @ts-ignore
+                    SessionDescriptionHandler.dispatchAddTrackEvent(localStream, newTrack);
+                }).catch((error) => {
+                    this.logger.error(`SessionDescriptionHandler.setLocalMediaStream - failed to replace sender ${kind} track`);
+                    throw error;
+                })));
             }
-            localStream.addTrack(newTrack);
-            SessionDescriptionHandler.dispatchAddTrackEvent(localStream, newTrack);
-          }),
-        );
-      }
-    };
-
-    // update peer connection audio tracks
-    const audioTracks = stream.getAudioTracks();
-    if (audioTracks.length) {
-      updateTrack(audioTracks[0]);
-    }
-
-    // update peer connection video tracks
-    const videoTracks = stream.getVideoTracks();
-    if (videoTracks.length) {
-      updateTrack(videoTracks[0]);
-    }
-
-    return trackUpdates.reduce((p, x) => p.then(() => x), Promise.resolve());
-  }
-
-  // Overridden to avoid replacing constraints with `localMediaStreamConstraints`
-  getLocalMediaStream(options        ) {
-    this.logger.debug('WazoSessionDescriptionHandler.getLocalMediaStream');
-    if (this._peerConnection === undefined) {
-      return Promise.reject(new Error('Peer connection closed.'));
+            else {
+                trackUpdates.push(new Promise(resolve => {
+                    this.logger.debug(`SessionDescriptionHandler.setLocalMediaStream - adding sender ${kind} track`);
+                    resolve(null);
+                }).then(() => {
+                    // Review: could make streamless tracks a configurable option?
+                    // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/addTrack#Usage_notes
+                    try {
+                        if (pc.addTrack) {
+                            pc.addTrack(newTrack, localStream);
+                        }
+                        else {
+                            pc.addStream(localStream);
+                        }
+                    }
+                    catch (error) {
+                        this.logger.error(`SessionDescriptionHandler.setLocalMediaStream - failed to add sender ${kind} track`);
+                        throw error;
+                    }
+                    localStream.addTrack(newTrack);
+                    // @ts-ignore
+                    SessionDescriptionHandler.dispatchAddTrackEvent(localStream, newTrack);
+                }));
+            }
+        };
+        // update peer connection audio tracks
+        const audioTracks = stream.getAudioTracks();
+        if (audioTracks.length) {
+            updateTrack(audioTracks[0]);
+        }
+        // update peer connection video tracks
+        const videoTracks = stream.getVideoTracks();
+        if (videoTracks.length) {
+            updateTrack(videoTracks[0]);
+        }
+        return trackUpdates.reduce((p, x) => p.then(() => x), Promise.resolve());
     }
-    let constraints = options.constraints ? { ...options.constraints } : {};
-    // if we already have a local media stream...
-    if (this.localMediaStreamConstraints) {
-      // if constraints have not changed, do not get a new media stream
-      if (JSON.stringify(this.localMediaStreamConstraints.audio) === JSON.stringify(constraints.audio)
-        && JSON.stringify(this.localMediaStreamConstraints.video) === JSON.stringify(constraints.video)) {
-        return Promise.resolve();
-      }
-    } else if (constraints.audio === undefined && constraints.video === undefined) {
-      // if no constraints have been specified, default to audio for initial media stream
-      constraints = { audio: true };
+    // Overridden to avoid replacing constraints with `localMediaStreamConstraints`
+    getLocalMediaStream(options) {
+        this.logger.debug('WazoSessionDescriptionHandler.getLocalMediaStream');
+        if (this._peerConnection === undefined) {
+            return Promise.reject(new Error('Peer connection closed.'));
+        }
+        let constraints = options.constraints ? { ...options.constraints,
+        } : {};
+        // if we already have a local media stream...
+        // @ts-ignore
+        if (this.localMediaStreamConstraints) {
+            // if constraints have not changed, do not get a new media stream
+            // @ts-ignore
+            if (JSON.stringify(this.localMediaStreamConstraints.audio) === JSON.stringify(constraints.audio) && JSON.stringify(this.localMediaStreamConstraints.video) === JSON.stringify(constraints.video)) {
+                return Promise.resolve();
+            }
+        }
+        else if (constraints.audio === undefined && constraints.video === undefined) {
+            // if no constraints have been specified, default to audio for initial media stream
+            constraints = {
+                audio: true,
+            };
+        }
+        // @ts-ignore
+        this.localMediaStreamConstraints = constraints;
+        // @ts-ignore
+        return this.mediaStreamFactory(constraints, this).then(mediaStream => {
+            this.setLocalMediaStream(mediaStream);
+            return mediaStream;
+        });
     }
-    this.localMediaStreamConstraints = constraints;
-    return this.mediaStreamFactory(constraints, this).then((mediaStream) => this.setLocalMediaStream(mediaStream));
-  }
 }
-
 export default WazoSessionDescriptionHandler;
-export { wazoMediaStreamFactory };