@wazo/sdk 0.37.0-rc.5 → 0.37.2

package/lib/simple/utils.js

@@ -11,7 +11,6 @@ var jsonToGraphQLQuery = require('json-to-graphql-query/lib/jsonToGraphQLQuery')
 var invitation = require('sip.js/lib/api/invitation');
 require('webrtc-adapter');
 var userAgentState = require('sip.js/lib/api/user-agent-state');
-require('sip.js/lib/api/message');
 var parser = require('sip.js/lib/core/messages/parser');
 var constants = require('sip.js/lib/core/messages/methods/constants');
 var uri = require('sip.js/lib/grammar/uri');
@@ -1015,7 +1014,7 @@ class Contact {
 
     return new Contact({
       sourceId: single.id || '',
-      name: single.displayName,
+      name: single.displayName || '',
       number: numbers.length ? numbers[0].number : '',
       numbers,
       emails,
@@ -1046,7 +1045,7 @@ class Contact {
 
     return new Contact({
       sourceId: single.id || '',
-      name: single.name,
+      name: single.name || '',
       number: numbers.length ? numbers[0].number : '',
       numbers,
       emails,
@@ -1147,7 +1146,7 @@ class Contact {
   }                   = {}) {
     this.id = id;
     this.uuid = uuid;
-    this.name = name;
+    this.name = name || '';
     this.number = number;
     this.numbers = numbers;
     this.email = email;
@@ -1822,7 +1821,13 @@ class IssueReporter {
   }
 
   _isLevelAbove(level1        , level2        ) {
-    return LOG_LEVELS.indexOf(level1) > LOG_LEVELS.indexOf(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        ) {
@@ -1845,7 +1850,7 @@ var IssueReporter$1 = new IssueReporter();
 
 const methods = ['head', 'get', 'post', 'put', 'delete'];
 
-const logger$a = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
+const logger$b = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
 
 // Use a function here to be able to mock it in tests
 const realFetch = () => {
@@ -1880,6 +1885,7 @@ class ApiRequester {
                        
                                  
                                      
+                           
 
                  
                 
@@ -1919,6 +1925,8 @@ class ApiRequester {
       this.token = token;
     }
 
+    this.shouldLogErrors = true;
+
     methods.forEach(method => {
       // $FlowFixMe
       ApiRequester.prototype[method] = function sugar(...args) {
@@ -1942,6 +1950,14 @@ class ApiRequester {
     this.fetchOptions = options;
   }
 
+  disableErrorLogging() {
+    this.shouldLogErrors = false;
+  }
+
+  enableErrorLogging() {
+    this.shouldLogErrors = true;
+  }
+
   async call(
     path        ,
     method         = 'get',
@@ -1973,7 +1989,7 @@ class ApiRequester {
     };
 
     if (this.refreshTokenPromise) {
-      logger$a.info('A token is already refreshing, waiting ...', { url });
+      logger$b.info('A token is already refreshing, waiting ...', { url });
       await this.refreshTokenPromise;
     }
 
@@ -1993,7 +2009,7 @@ class ApiRequester {
         return promise.then(async (err        ) => {
           // Check if the token is still valid
           if (firstCall && this._checkTokenExpired(response, err)) {
-            logger$a.warn('token expired', { error: err.reason });
+            logger$b.warn('token expired', { error: err.reason });
             // Replay the call after refreshing the token
             return this._replayWithNewToken(err, path, method, body, headers, parse);
           }
@@ -2002,7 +2018,9 @@ class ApiRequester {
             ? exceptionClass.fromText(err, response.status)
             : exceptionClass.fromResponse(err, response.status);
 
-          logger$a.error('API error', error);
+          if (this.shouldLogErrors) {
+            logger$b.error('API error', error);
+          }
 
           throw error;
         });
@@ -2010,7 +2028,9 @@ class ApiRequester {
 
       return newParse(response, isJson);
     }).catch(error => {
-      logger$a.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+      if (this.shouldLogErrors) {
+        logger$b.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+      }
 
       throw error;
     });
@@ -2037,13 +2057,13 @@ class ApiRequester {
   ) {
     const isTokenNotFound = this._isTokenNotFound(err);
     let newPath = path;
-    logger$a.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
+    logger$b.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
 
     this.refreshTokenPromise = this.refreshTokenPromise || this.refreshTokenCallback();
 
     return this.refreshTokenPromise.then(() => {
       this.refreshTokenPromise = null;
-      logger$a.info('token refreshed', { isTokenNotFound });
+      logger$b.info('token refreshed', { isTokenNotFound });
       if (isTokenNotFound) {
         const pathParts = path.split('/');
         pathParts.pop();
@@ -3325,7 +3345,7 @@ class CallSession {
     return newFrom(callSession, CallSession);
   }
 
-  static parseCall(session         , call      )              {
+  static parseCall(call      )              {
     return new CallSession({
       callId: call.id,
       sipCallId: call.sipCallId,
@@ -3378,17 +3398,66 @@ class Emitter {
 
 //      
 
+                                 
+                   
+                    
+                   
+                     
+               
+  
+
+                           
+                   
+             
+                   
+              
+               
+ 
+
+class Recording {
+                   
+             
+                   
+              
+               
+
+  static parseMany(recordings                     )              {
+    return recordings.map(item => Recording.parse(item));
+  }
+
+  static parse(plain                   )            {
+    return new Recording({
+      deleted: plain.deleted,
+      fileName: plain.filename,
+      end: plain.end_time ? moment__default['default'](plain.end_time).toDate() : null,
+      start: moment__default['default'](plain.start_time).toDate(),
+      uuid: plain.uuid,
+    });
+  }
+
+  constructor({ deleted, end, fileName, start, uuid }                    ) {
+    this.deleted = deleted;
+    this.end = end;
+    this.fileName = fileName;
+    this.start = start;
+    this.uuid = uuid;
+  }
+}
+
+//      
+
                         
-                 
+                  
                     
                          
                                 
                             
                    
-              
+               
              
                            
                       
+                                  
                               
                          
                 
@@ -3401,7 +3470,7 @@ class Emitter {
   
 
                          
-               
+                
                     
                           
                         
@@ -3416,13 +3485,14 @@ class Emitter {
              
                    
               
-            
+             
+                          
   
 
 class CallLog {
                
 
-               
+                
                     
                          
                         
@@ -3439,7 +3509,7 @@ class CallLog {
              
                    
               
-            
+             
 
   static merge(current                , toMerge                )                  {
     const onlyUnique = (value, index, self) => self.indexOf(value) === index;
@@ -3456,7 +3526,7 @@ class CallLog {
 
   static parse(plain                 )          {
     return new CallLog({
-      answer: moment__default['default'](plain.answer).toDate(),
+      answer: plain.answer ? moment__default['default'](plain.answer).toDate() : null,
       answered: plain.answered,
       callDirection: plain.call_direction,
       destination: {
@@ -3470,13 +3540,14 @@ class CallLog {
       id: plain.id,
       duration: (plain.duration || 0) * 1000, // duration is in seconds
       start: moment__default['default'](plain.start).toDate(),
-      end: moment__default['default'](plain.end).toDate(),
+      end: plain.end ? moment__default['default'](plain.end).toDate() : null,
+      recordings: Recording.parseMany(plain.recordings),
     });
   }
 
   static parseNew(plain                 , session         )          {
     return new CallLog({
-      answer: moment__default['default'](plain.answer).toDate(),
+      answer: plain.answer ? moment__default['default'](plain.answer).toDate() : null,
       answered: plain.answered,
       callDirection: plain.call_direction,
       destination: {
@@ -3490,7 +3561,8 @@ class CallLog {
       id: plain.id,
       duration: (plain.duration || 0) * 1000, // duration is in seconds
       start: moment__default['default'](plain.start).toDate(),
-      end: moment__default['default'](plain.end).toDate(),
+      end: plain.end ? moment__default['default'](plain.end).toDate() : null,
+      recordings: Recording.parseMany(plain.recordings),
       // @TODO: FIXME add verification declined vs missed call
       newMissedCall: session
         && session.hasExtension(plain.requested_extension || plain.destination_extension) && !plain.answered,
@@ -3672,11 +3744,414 @@ class IndirectTransfer {
 }
 
 //      
+
+class CallApi {
+  static async fetchCallLogs(offset        , limit        )                  {
+    return getApiClient().callLogd.listCallLogs(offset, limit);
+  }
+
+  static async fetchDistinctCallLogs(offset        , limit        , distinct         = 'peer_exten')                  {
+    return getApiClient().callLogd.listDistinctCallLogs(offset, limit, distinct);
+  }
+
+  static async fetchActiveCalls()                  {
+    return getApiClient().calld.listCalls();
+  }
+
+  static async fetchCallLogsFromDate(from      , number        )                     {
+    return getApiClient().callLogd.listCallLogsFromDate(from, number);
+  }
+
+  static async search(query        , limit        )                     {
+    return getApiClient().callLogd.search(query, limit);
+  }
+
+  static async searchBy(field        , value        , limit        )                     {
+    return getApiClient().callLogd.searchBy(field, value, limit);
+  }
+
+  static async fetchSIP(session         , line       )               {
+    const lineToUse = line || session.primaryLine();
+    return getApiClient().confd.getUserLineSip(session.uuid, lineToUse ? lineToUse.id : null);
+  }
+
+  static async cancelCall(callSession             )                {
+    return getApiClient().calld.cancelCall(callSession.callId);
+  }
+
+  static async makeCall(callFromLine      , extension        , isMobile          = false,
+    callbackAllLines          = false)                 {
+    const lineId = callFromLine ? callFromLine.id : null;
+
+    const response = await getApiClient().calld.makeCall(extension, isMobile, lineId, callbackAllLines);
+    return Call.parse(response);
+  }
+
+  static async relocateCall(callId        , line        , contactIdentifier         )                      {
+    return getApiClient().calld.relocateCall(callId, 'line', line, contactIdentifier);
+  }
+
+  static async hold(callId        )                {
+    return getApiClient().calld.hold(callId);
+  }
+
+  static async resume(callId        )                {
+    return getApiClient().calld.resume(callId);
+  }
+
+  static async mute(callId        )                {
+    return getApiClient().calld.mute(callId);
+  }
+
+  static async sendDTMF(callId        , digits        )                {
+    return getApiClient().calld.sendDTMF(callId, digits);
+  }
+
+  static async unmute(callId        )                {
+    return getApiClient().calld.unmute(callId);
+  }
+
+  static async transferCall(callId        , number        , flow        )                    {
+    return getApiClient().calld.transferCall(callId, number, flow);
+  }
+
+  static async cancelCallTransfer(transferId        )                    {
+    return getApiClient().calld.cancelCallTransfer(transferId);
+  }
+
+  static async confirmCallTransfer(transferId        )                    {
+    return getApiClient().calld.confirmCallTransfer(transferId);
+  }
+}
+
+//      
+
+const TRANSFER_FLOW_ATTENDED = 'attended';
 const TRANSFER_FLOW_BLIND = 'blind';
 
 // const MINIMUM_WAZO_ENGINE_VERSION_FOR_CTI_HOLD = '20.11';
 
-IssueReporter$1 ? IssueReporter$1.loggerFor('cti-phone') : console;
+const logger$a = IssueReporter$1 ? IssueReporter$1.loggerFor('cti-phone') : console;
+
+class CTIPhone extends Emitter                  {
+                   
+
+                    
+
+                            
+
+                     
+
+  constructor(session         , isMobile          = false, callbackAllLines          = false) {
+    super();
+    logger$a.info('CTI Phone created');
+    this.session = session;
+    this.isMobile = isMobile;
+    this.callbackAllLines = callbackAllLines;
+  }
+
+  getOptions()                        {
+    // @FIXME: temporarily disabling this option
+    // const hold = this.session.hasEngineVersionGte(MINIMUM_WAZO_ENGINE_VERSION_FOR_CTI_HOLD);
+
+    return {
+      accept: false,
+      decline: true,
+      mute: true,
+      hold: false,
+      transfer: true,
+      sendKey: true,
+      addParticipant: false,
+      record: true,
+      merge: false,
+    };
+  }
+
+  hasAnActiveCall() {
+    return !!this.currentCall;
+  }
+
+  callCount() {
+    return this.currentCall ? 1 : 0;
+  }
+
+  isWebRTC() {
+    return false;
+  }
+
+  getUserAgent() {
+    return 'cti-phone';
+  }
+
+  startHeartbeat() {
+  }
+
+  setOnHeartbeatTimeout() {
+  }
+
+  setOnHeartbeatCallback() {
+  }
+
+  stopHeartbeat() {
+  }
+
+  bindClientEvents() {
+  }
+
+  onConnect() {
+  }
+
+  onDisconnect() {
+  }
+
+  async makeCall(number        , line      )                        {
+    logger$a.info('make CTI call', { number });
+
+    if (!number) {
+      return null;
+    }
+    try {
+      this.currentCall = await CallApi.makeCall(line, number, this.isMobile, this.callbackAllLines);
+    } catch (_) {
+      // We have to deal with error like `User has no mobile phone number` error in the UI.
+    }
+    if (!this.currentCall) {
+      return null;
+    }
+    const callSession = CallSession.parseCall(this.currentCall);
+    this.eventEmitter.emit('onCallOutgoing', callSession);
+
+    return callSession;
+  }
+
+  accept(callSession             )                         {
+    if (!callSession) {
+      return Promise.resolve(null);
+    }
+    logger$a.info('accept CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    if (!this.currentCall) {
+      this.currentCall = callSession.call;
+    }
+
+    return Promise.resolve(callSession.getId());
+  }
+
+  endCurrentCall(callSession             )       {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('end current CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    this.currentCall = undefined;
+    this.eventEmitter.emit('onCallEnded', callSession);
+  }
+
+  async hangup(callSession             )                   {
+    if (!callSession) {
+      return Promise.resolve(false);
+    }
+    logger$a.info('hangup CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    try {
+      await CallApi.cancelCall(callSession);
+      if (this.currentCall && callSession.callId === this.currentCall.id) {
+        this.endCurrentCall(callSession);
+      }
+
+      this.eventEmitter.emit('onCallEnded', callSession);
+      return true;
+    } catch (e) {
+      logger$a.error('hangup CTI call, error', e);
+
+      this.eventEmitter.emit('onCallFailed', callSession);
+      return false;
+    }
+  }
+
+  ignore() {}
+
+  async reject(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('reject CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    await CallApi.cancelCall(callSession);
+    this.eventEmitter.emit('onCallEnded', callSession);
+  }
+
+  async transfer(callSession             , number        )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('transfer CTI call', { callId: callSession.getId(), number: callSession.number, to: number });
+
+    await CallApi.transferCall(callSession.callId, number, TRANSFER_FLOW_BLIND);
+  }
+
+  indirectTransfer() {}
+
+  async initiateCTIIndirectTransfer(callSession             , number        )               {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('indirect CTI transfer', { callId: callSession.getId(), number: callSession.number, to: number });
+
+    return CallApi.transferCall(callSession.callId, number, TRANSFER_FLOW_ATTENDED);
+  }
+
+  async cancelCTIIndirectTransfer(transferId        )               {
+    logger$a.info('cancel CTI transfer', { transferId });
+
+    return CallApi.cancelCallTransfer(transferId);
+  }
+
+  async confirmCTIIndirectTransfer(transferId        )               {
+    logger$a.info('confirm CTI transfer', { transferId });
+
+    return CallApi.confirmCallTransfer(transferId);
+  }
+
+  sendKey(callSession             , digits        ) {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('send CTI key', { callId: callSession.getId(), number: callSession.number, digits });
+
+    return CallApi.sendDTMF(callSession.callId, digits);
+  }
+
+  onConnectionMade() {
+    logger$a.info('on CTI connection made');
+
+    this.eventEmitter.emit('onCallAccepted');
+  }
+
+  async close() {
+    logger$a.info('CTI close');
+
+    return Promise.resolve();
+  }
+
+  async hold(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI hold', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.hold(callSession.callId);
+  }
+
+  async resume(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI resume', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.resume(callSession.callId);
+  }
+
+  async mute(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI mute', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.mute(callSession.callId);
+  }
+
+  async unmute(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI unmute', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.unmute(callSession.callId);
+  }
+
+  putOnSpeaker() {}
+
+  putOffSpeaker() {}
+
+  turnCameraOff() {}
+
+  turnCameraOn() {}
+
+  changeAudioInputDevice() {}
+
+  changeVideoInputDevice() {}
+
+  changeAudioDevice() {}
+
+  changeRingDevice() {}
+
+  changeAudioVolume() {}
+
+  changeRingVolume() {}
+
+  hasVideo()          {
+    return false;
+  }
+
+  getLocalStreamForCall()               {
+    return null;
+  }
+
+  getRemoteStreamForCall()               {
+    return null;
+  }
+
+  getLocalVideoStream()               {
+    return null;
+  }
+
+  setActiveSipSession() {}
+
+  isRegistered()          {
+    return true;
+  }
+
+  hasIncomingCallSession()          {
+    return true;
+  }
+
+  hasActiveRemoteVideoStream()          {
+    return false;
+  }
+
+  getCurrentCallSession()               {
+    return this.currentCall ? CallSession.parseCall(this.currentCall) : null;
+  }
+
+  enableRinging() {}
+
+  sendMessage() {}
+
+  disableRinging() {}
+
+  getLocalStream() {
+    return null;
+  }
+
+  getRemoteStream() {
+    return null;
+  }
+
+  getRemoteVideoStream() {
+    return null;
+  }
+
+  getRemoteAudioStream() {
+    return null;
+  }
+
+  hasLocalVideo() {
+    return false;
+  }
+
+  useLocalVideoElement() {}
+}
 
 /*       */
 
@@ -4711,6 +5186,10 @@ class ApiClient {
     this.fetchOptions = fetchOptions;
     this.client.setFetchOptions(fetchOptions);
   }
+
+  disableErrorLogging() {
+    this.client.disableErrorLogging();
+  }
 }
 
 /* eslint-disable dot-notation */
@@ -5252,23 +5731,6 @@ const areCandidateValid = (candidates          )          =>
   getSrflxOrRelay(candidates)
     .length > 0;
 
-const toggleVideoDirection = (sdp        , direction         )         => {
-  const parsedSdp = sdpParser__default['default'].parse(sdp);
-  parsedSdp.media = parsedSdp.media.map(media => ({
-    ...media,
-    ...(media.type === 'video' ? { direction } : {}),
-  }));
-
-  return sdpParser__default['default'].write(parsedSdp);
-};
-
-const deactivateVideoModifier = (rawDescription        )                  => {
-  const description = rawDescription;
-  description.sdp = toggleVideoDirection(description.sdp, 'inactive');
-
-  return Promise.resolve(description);
-};
-
 const hasAnActiveVideo = (sdp         )          => {
   if (!sdp) {
     return false;
@@ -5380,6 +5842,7 @@ class WazoSessionDescriptionHandler extends sessionDescriptionHandler.SessionDes
     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
@@ -5406,16 +5869,16 @@ class WazoSessionDescriptionHandler extends sessionDescriptionHandler.SessionDes
     };
 
     return this.getLocalMediaStream(options)
-      .then(() => this.updateDirection(options, isConference))
+      .then(() => this.updateDirection(options, isConference, audioOnly))
       .then(() => this.createDataChannel(options))
       .then(() => {
-        if (isConference && (options.constraints && !options.constraints.video) && !('hold' in options)) {
+        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
           this.peerConnection.addTransceiver('video', { streams: [this._localMediaStream], direction: 'sendrecv' });
         }
       })
       .then(() => this.createLocalOfferOrAnswer(options))
-      .then((sessionDescription) => this.setLocalSessionDescription(sessionDescription))
+      .then(sessionDescription => this.setLocalSessionDescription(sessionDescription))
       .then(() => this.waitForIceGatheringComplete(iceRestart, iceTimeout))
       .then(() => this.getLocalSessionDescription())
       .then(description => {
@@ -5538,7 +6001,8 @@ class WazoSessionDescriptionHandler extends sessionDescriptionHandler.SessionDes
   }
 
   // Overridden to send `inactive` in conference
-  updateDirection(options                                   , isConference          = false)                {
+  updateDirection(options                                   , isConference          = false,
+    audioOnly          = false)                {
     if (this._peerConnection === undefined) {
       return Promise.reject(new Error('Peer connection closed.'));
     }
@@ -5553,14 +6017,17 @@ class WazoSessionDescriptionHandler extends sessionDescriptionHandler.SessionDes
         // 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        )         => {
+        const directionToOffer = (currentDirection        , transceiver         /* RTCRtpTransceiver */)         => {
           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' : 'recvonly';
+              return options && options.hold ? 'inactive' : (isConference && !audioOnly ? 'sendrecv' : 'recvonly');
             case 'recvonly':
               return options && options.hold ? 'inactive' : 'recvonly';
             case 'sendonly':
@@ -5576,7 +6043,7 @@ class WazoSessionDescriptionHandler extends sessionDescriptionHandler.SessionDes
         // 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);
+            const offerDirection = directionToOffer(transceiver.direction, transceiver);
             if (transceiver.direction !== offerDirection) {
               // eslint-disable-next-line no-param-reassign
               transceiver.direction = offerDirection;
@@ -5635,6 +6102,13 @@ class WazoSessionDescriptionHandler extends sessionDescriptionHandler.SessionDes
         // set the transceiver direction to the answer direction
         this._peerConnection.getTransceivers().forEach((transceiver) => {
           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;
@@ -5673,8 +6147,8 @@ class WazoSessionDescriptionHandler extends sessionDescriptionHandler.SessionDes
       }
       const sender = pc.getSenders().find((otherSender) => otherSender.track && otherSender.track.kind === kind);
 
-      // Do not reuse sender tracks in SFU
-      if (sender && !sfu) {
+      // Do not reuse sender video tracks in SFU
+      if (sender && (!sfu || newTrack.kind === 'audio')) {
         trackUpdates.push(
           new Promise((resolve) => {
             this.logger.debug(`SessionDescriptionHandler.setLocalMediaStream - replacing sender ${kind} track`);
@@ -6226,9 +6700,15 @@ class WebRTCClient extends Emitter {
 
   call(number        , enableVideo          , audioOnly          = false, conference          = false)          {
     logger$7.info('sdk webrtc creating call', { number, enableVideo, audioOnly });
-    const inviterOptions = {};
+    const inviterOptions         = {
+      sessionDescriptionHandlerOptionsReInvite: {
+        conference,
+        audioOnly,
+      },
+    };
+
     if (audioOnly) {
-      inviterOptions.sessionDescriptionHandlerModifiersReInvite = [deactivateVideoModifier];
+      inviterOptions.sessionDescriptionHandlerModifiersReInvite = [modifiers.stripVideo];
     }
 
     const session = new inviter.Inviter(this.userAgent, this._makeURI(number), inviterOptions);
@@ -6257,10 +6737,11 @@ class WebRTCClient extends Emitter {
       sessionDescriptionHandlerOptions: this.getMediaConfiguration(enableVideo || false, conference),
     };
 
-    inviteOptions.sessionDescriptionHandlerModifiers = [replaceLocalIpModifier];
+    inviteOptions.sessionDescriptionHandlerOptions.audioOnly = audioOnly;
 
+    inviteOptions.sessionDescriptionHandlerModifiers = [replaceLocalIpModifier];
     if (audioOnly) {
-      inviteOptions.sessionDescriptionHandlerModifiers.push(deactivateVideoModifier);
+      inviteOptions.sessionDescriptionHandlerModifiers.push(modifiers.stripVideo);
     }
 
     // Do not await invite here or we'll miss the Establishing state transition
@@ -6474,6 +6955,9 @@ class WebRTCClient extends Emitter {
     if (!this._isWeb()) {
       options.sessionDescriptionHandlerModifiers = [modifiers.holdModifier];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -6513,6 +6997,9 @@ class WebRTCClient extends Emitter {
       // (eg: holdModifier)
       options.sessionDescriptionHandlerModifiers = [];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -6742,7 +7229,8 @@ class WebRTCClient extends Emitter {
       ? this.video.deviceId.exact : undefined;
   }
 
-  reinvite(sipSession         , newConstraints          = null, conference          = false) {
+  reinvite(sipSession         , newConstraints          = null, conference          = false,
+    audioOnly          = false) {
     if (!sipSession) {
       return false;
     }
@@ -6752,16 +7240,17 @@ class WebRTCClient extends Emitter {
     }
 
     const wasMuted = this.isAudioMuted(sipSession);
-    // When upgrading to video, remove the `deactivateVideoModifier` modifiers
+    // When upgrading to video, remove the `stripVideo` modifiers
     if (newConstraints && newConstraints.video) {
-      const modifiers = sipSession.sessionDescriptionHandlerModifiersReInvite;
-      sipSession.sessionDescriptionHandlerModifiersReInvite = modifiers.filter(modifier =>
-        modifier !== deactivateVideoModifier);
+      const modifiers$1 = sipSession.sessionDescriptionHandlerModifiersReInvite;
+      sipSession.sessionDescriptionHandlerModifiersReInvite = modifiers$1.filter(modifier =>
+        modifier !== modifiers.stripVideo);
     }
 
     sipSession.sessionDescriptionHandlerOptionsReInvite = {
       ...sipSession.sessionDescriptionHandlerOptionsReInvite,
       conference,
+      audioOnly,
     };
 
     const shouldDoVideo = newConstraints ? newConstraints.video : this.sessionWantsToDoVideo(sipSession);
@@ -6801,6 +7290,8 @@ class WebRTCClient extends Emitter {
       },
       sessionDescriptionHandlerOptions: {
         constraints,
+        conference,
+        audioOnly,
         offerOptions: {
           iceRestart: false,
         },
@@ -7260,6 +7751,8 @@ class WebRTCClient extends Emitter {
 
   // 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 = {};
@@ -7283,8 +7776,18 @@ class WebRTCClient extends Emitter {
       };
     };
 
+    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
+    // Becase when `onInvite` is called we already got the video track
+    session.onInviteRequest = (request) => {
+      hadRemoteVideo = this.hasARemoteVideoTrack(sipSessionId);
+
+      oldInviteRequest(request);
+    };
+
     session.delegate.onInvite = (request                        ) => {
-      const sipSessionId = this.getSipSessionId(session);
       let updatedCalleeName = null;
       let updatedNumber = null;
       if (session.assertedIdentity) {
@@ -7294,7 +7797,6 @@ class WebRTCClient extends Emitter {
       logger$7.info('re-invite received', { updatedCalleeName, updatedNumber });
 
       // Useful to know if it's a video upgrade or an unhold from a remote peer with a video stream
-      const hadRemoteVideo = this.hasARemoteVideoTrack(sipSessionId);
 
       // Update SDP
       // Remote video is handled by the `track` event. Here we're dealing with video stream removal.
@@ -7344,7 +7846,7 @@ class WebRTCClient extends Emitter {
   }
 
   _isAudioOnly(session         )          {
-    return session.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === deactivateVideoModifier);
+    return session.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === modifiers.stripVideo);
   }
 
   _setupMedias(session         , newStream              ) {
@@ -7717,9 +8219,14 @@ class WebRTCPhone extends Emitter                  {
     return true;
   }
 
-  async sendReinvite(callSession              , constraints          = null, conference          = false) {
+  async sendReinvite(callSession              , constraints          = null, conference          = false,
+    audioOnly          = false) {
     const sipSession = this.findSipSession(callSession);
-    logger$6.info('WebRTC phone - send reinvite', { sessionId: sipSession ? sipSession.id : null, constraints });
+    logger$6.info('WebRTC phone - send reinvite', {
+      sessionId: sipSession ? sipSession.id : null,
+      constraints,
+      audioOnly,
+    });
 
     if (!sipSession) {
       return null;
@@ -7745,7 +8252,7 @@ class WebRTCPhone extends Emitter                  {
     // Force reinvite in SDH
     sipSession.sessionDescriptionHandler.localMediaStreamConstraints = null;
 
-    return this.client.reinvite(sipSession, constraints, conference);
+    return this.client.reinvite(sipSession, constraints, conference, audioOnly);
   }
 
   getUserAgent() {
@@ -7821,9 +8328,9 @@ class WebRTCPhone extends Emitter                  {
     }
 
     // Release local video stream when downgrading to audio
-    const localVideoStream = sipSession.sessionDescriptionHandler.localMediaStream;
+    const localStream = sipSession.sessionDescriptionHandler.localMediaStream;
     const pc = sipSession.sessionDescriptionHandler.peerConnection;
-    const videoTracks = localVideoStream.getVideoTracks();
+    const videoTracks = localStream.getVideoTracks();
 
     // Remove video senders
     pc.getSenders().filter(sender => sender.track && sender.track.kind === 'video').forEach(videoSender => {
@@ -7838,7 +8345,7 @@ class WebRTCPhone extends Emitter                  {
     videoTracks.forEach(videoTrack => {
       videoTrack.enabled = false;
       videoTrack.stop();
-      localVideoStream.removeTrack(videoTrack);
+      localStream.removeTrack(videoTrack);
     });
 
     this._sendReinviteMessage(callSession, false);
@@ -7855,12 +8362,14 @@ class WebRTCPhone extends Emitter                  {
 
     const pc = sipSession.sessionDescriptionHandler.peerConnection;
     const shouldScreenShare = constraints && constraints.screen;
+    const options = sipSession.sessionDescriptionHandlerOptionsReInvite;
+    const wasAudioOnly = options && options.audioOnly;
 
     // Check if a video sender already exists
     let videoSender;
     if (isConference) {
       const trans = pc.getTransceivers().find(transceiver => transceiver.mid === '1');
-      videoSender = trans.sender;
+      videoSender = trans ? trans.sender : null;
     } else {
       videoSender = pc.getSenders().find(sender => sender.track === null);
     }
@@ -7897,6 +8406,11 @@ class WebRTCPhone extends Emitter                  {
       this._onScreenSharing(newStream, sipSession, callSession, false);
     }
 
+    // We have to reinvite to change the direction on the bundle when upgrading from an audioOnly conference
+    if (isConference && wasAudioOnly) {
+      return true;
+    }
+
     // No reinvite needed here
     return false;
   }
@@ -7981,7 +8495,7 @@ class WebRTCPhone extends Emitter                  {
         event.track.enabled = false;
       }
 
-      return this.eventEmitter.emit(ON_VIDEO_STREAM, stream, event.track.id, event);
+      return this.eventEmitter.emit(ON_VIDEO_STREAM, stream, event.track.id, event, sipSession);
     };
 
     peerConnection.onremovestream = event => {
@@ -8037,14 +8551,11 @@ class WebRTCPhone extends Emitter                  {
         const targetCallSession = callSession || this.currentCallSession;
         const conference = this.isConference(targetCallSession);
 
-        if (this.currentScreenShare.sender && this.currentScreenShare.hadVideo) {
-          // When stopping screenshare and we had video before that, we have to re-upgrade
-          await this.sendReinvite(targetCallSession, { audio: false, video: true }, conference);
-        } else {
-          // When upgrading directly to screenshare (eg: we don't have a videoLocalStream to replace)
-          // We have to downgrade to audio.
-          await this.sendReinvite(targetCallSession, { audio: false, video: false }, conference);
-        }
+        // When stopping screenshare and we had video before that, we have to re-upgrade
+        // When upgrading directly to screenshare (eg: we don't have a videoLocalStream to replace)
+        // We have to downgrade to audio.
+        const screenshareStopped = this.currentScreenShare.sender && this.currentScreenShare.hadVideo;
+        await this.sendReinvite(targetCallSession, { audio: false, video: screenshareStopped }, conference);
       }
     } catch (e) {
       console.warn(e);
@@ -8381,6 +8892,7 @@ class WebRTCPhone extends Emitter                  {
     }
   }
 
+  // @Deprecated
   unhold(callSession             , withEvent          = true, isConference          = false)       {
     logger$6.info('WebRTC unhold', { id: callSession ? callSession.getId() : null });
 
@@ -9378,6 +9890,7 @@ class Phone extends Emitter {
     return this.phone && this.phone.hasLocalVideo(callSession);
   }
 
+  // @Deprecated
   getLocalMediaStream(callSession             ) {
     logger$5.warn('Phone.getLocalMediaStream is deprecated, use Phone.getLocalStream instead');
 
@@ -9396,17 +9909,20 @@ class Phone extends Emitter {
     return this.phone ? this.phone.getRemoteVideoStream(callSession) : null;
   }
 
+  // @Deprecated
   getRemoteStreamForCall(callSession             ) {
     logger$5.warn('Phone.getRemoteStreamForCall is deprecated, use Phone.getRemoteStream instead');
     return this.getRemoteStream(callSession);
   }
 
   // Returns remote streams directly from the peerConnection
+  // @Deprecated
   getRemoteStreamsForCall(callSession             ) {
-    logger$5.warn('Phone.getRe is deprecated, use Phone.getLocalStream instead');
+    logger$5.warn('Phone.getRemoteStreamsForCall is deprecated, use Phone.getLocalStream instead');
     return this.getLocalStream(callSession);
   }
 
+  // @Deprecated
   getRemoteVideoStreamForCall(callSession             ) {
     logger$5.warn('Phone.getRemoteVideoStreamForCall is deprecated, use Phone.getRemoteVideoStream instead');
 
@@ -10769,13 +11285,15 @@ class Room$1 extends Emitter {
       }
     });
 
-    this.on(this.ON_VIDEO_STREAM, (stream, streamId) => {
+    this.on(this.ON_VIDEO_STREAM, (stream, streamId, event, sipSession) => {
       logger$1.info('on room video stream', { streamId });
 
+      this._mapMsid(sipSession.body.body);
+
       // ON_VIDEO_STREAM is called before PARTICIPANT_JOINED, so we have to keep stream in `_unassociatedVideoStreams`.
       this._unassociatedVideoStreams[streamId] = stream;
 
-      const callId = this._getCallIdFromStreamId(streamId);
+      const callId = this._getCallIdFromTrackId(streamId);
       const participant = callId ? this._getParticipantFromCallId(callId) : null;
       if (participant) {
         this.__associateStreams(participant);
@@ -10819,11 +11337,12 @@ class Room$1 extends Emitter {
     const sdp = sdpParser__default['default'].parse(rawSdp);
     const labelMsidArray = sdp.media.filter(media => !!media.label).map(({ label, msid }) => ({
       label: String(label),
-      msid: msid.split(' ')[1],
+      streamId: msid.split(' ')[0],
+      trackId: msid.split(' ')[1],
     }));
 
-    labelMsidArray.forEach(({ label, msid }) => {
-      this._callIdStreamIdMap[String(label)] = msid;
+    labelMsidArray.forEach(({ label, streamId, trackId }) => {
+      this._callIdStreamIdMap[String(label)] = { streamId, trackId };
 
       const callId = String(label);
       const participant = this._unassociatedParticipants[callId] || this._getParticipantFromCallId(callId);
@@ -11053,9 +11572,9 @@ class Room$1 extends Emitter {
   _onParticipantTrackUpdate(oldParticipant             , update        )              {
     const newParticipant = oldParticipant;
 
-    const label = this._callIdStreamIdMap[newParticipant.callId];
+    const { trackId } = this._callIdStreamIdMap[newParticipant.callId] || {};
     const pc = Wazo.Phone.phone.currentSipSession.sessionDescriptionHandler.peerConnection;
-    const stream = pc.getRemoteStreams().find(otherStream => otherStream.getTracks().some(track => track.id === label));
+    const stream = pc.getRemoteStreams().find(someStream => someStream.getTracks().some(track => track.id === trackId));
 
     if (update === 'downgrade') {
       newParticipant.streams = [];
@@ -11075,21 +11594,21 @@ class Room$1 extends Emitter {
 
   // Associate audio/video streams to the participant and triggers events on it
   __associateStreams(participant             ) {
-    const streamId = this._callIdStreamIdMap[participant.callId];
-    if (!streamId) {
+    const { trackId } = this._callIdStreamIdMap[participant.callId] || {};
+    if (!trackId) {
       this._unassociatedParticipants[participant.callId] = participant;
 
       return;
     }
-    if (!streamId || !participant || !this.localParticipant || participant.callId === this.localParticipant.callId) {
+    if (!trackId || !participant || !this.localParticipant || participant.callId === this.localParticipant.callId) {
       return;
     }
 
-    if (this._unassociatedVideoStreams[streamId]) {
+    if (this._unassociatedVideoStreams[trackId]) {
       // Try to associate stream
-      this._associateStreamTo(this._unassociatedVideoStreams[streamId], participant);
+      this._associateStreamTo(this._unassociatedVideoStreams[trackId], participant);
 
-      delete this._unassociatedVideoStreams[streamId];
+      delete this._unassociatedVideoStreams[trackId];
       delete this._unassociatedParticipants[participant.callId];
     }
   }
@@ -11102,8 +11621,8 @@ class Room$1 extends Emitter {
     participant.onStreamSubscribed(stream);
   }
 
-  _getCallIdFromStreamId(streamId        ) {
-    return Object.keys(this._callIdStreamIdMap).find(key => this._callIdStreamIdMap[key] === streamId);
+  _getCallIdFromTrackId(trackId        ) {
+    return Object.keys(this._callIdStreamIdMap).find(key => this._callIdStreamIdMap[key].trackId === trackId);
   }
 
   _getParticipantFromCallId(callId        ) {
@@ -11152,10 +11671,7 @@ class Stream {
     element.onloadedmetadata = () => {
       const tracks = this.htmlStream ? this.htmlStream.getVideoTracks() : [];
       tracks.forEach(track => {
-        // Do not re-enable the track if already mounted.
-        if (!track.loaded) {
-          track.enabled = true;
-        }
+        track.enabled = true;
         // $FlowFixMe
         track.loaded = true;
       });
@@ -11580,6 +12096,7 @@ var api = {
   check: async (server, session) => {
     const client = new ApiClient({ server });
     client.setToken(session.token);
+    client.disableErrorLogging();
 
     const handleApiError = (apiName, error) => {
       const statusText = error instanceof ServerError ? 'server error' : 'api error';
@@ -11654,6 +12171,8 @@ var aor = {
   check: async (server, session) => {
     const apiClient = new ApiClient({ server });
     apiClient.setToken(session.token);
+    apiClient.disableErrorLogging();
+
     const line = session.primaryWebRtcLine();
     if (!line) {
       return 'No WebRTC line for this user';
@@ -12076,6 +12595,8 @@ const Wazo = {
     ServerError,
     Call,
     CallLog,
+    CTIPhone,
+    Recording,
     ChatMessage,
     ChatRoom,
     Contact,
@@ -12090,6 +12611,7 @@ const Wazo = {
     CallSession,
     IndirectTransfer,
     SwitchboardCall,
+    WebRTCPhone,
   },
 
   // Api