@wazo/sdk 0.37.0 → 0.37.4

package/esm/simple/room/Stream.js

@@ -1809,7 +1809,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        ) {
@@ -1832,7 +1838,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$c = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
 
 // Use a function here to be able to mock it in tests
 const realFetch = () => {
@@ -1971,7 +1977,7 @@ class ApiRequester {
     };
 
     if (this.refreshTokenPromise) {
-      logger$a.info('A token is already refreshing, waiting ...', { url });
+      logger$c.info('A token is already refreshing, waiting ...', { url });
       await this.refreshTokenPromise;
     }
 
@@ -1991,7 +1997,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$c.warn('token expired', { error: err.reason });
             // Replay the call after refreshing the token
             return this._replayWithNewToken(err, path, method, body, headers, parse);
           }
@@ -2001,7 +2007,7 @@ class ApiRequester {
             : exceptionClass.fromResponse(err, response.status);
 
           if (this.shouldLogErrors) {
-            logger$a.error('API error', error);
+            logger$c.error('API error', error);
           }
 
           throw error;
@@ -2011,7 +2017,7 @@ class ApiRequester {
       return newParse(response, isJson);
     }).catch(error => {
       if (this.shouldLogErrors) {
-        logger$a.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+        logger$c.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
       }
 
       throw error;
@@ -2039,13 +2045,13 @@ class ApiRequester {
   ) {
     const isTokenNotFound = this._isTokenNotFound(err);
     let newPath = path;
-    logger$a.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
+    logger$c.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$c.info('token refreshed', { isTokenNotFound });
       if (isTokenNotFound) {
         const pathParts = path.split('/');
         pathParts.pop();
@@ -2506,6 +2512,65 @@ class ExternalApp {
   }
 }
 
+//      
+
+                                       
+                                  
+                   
+               
+                             
+               
+               
+                
+ 
+
+class Meeting {
+               
+
+                                
+                   
+               
+               
+               
+                 
+                            
+
+  static parse(plain                         )          {
+    return new Meeting({
+      guestSipAuthorization: plain.guest_sip_authorization,
+      hostname: plain.hostname,
+      name: plain.name,
+      ownerUuids: plain.owner_uuids,
+      port: plain.port,
+      uuid: plain.uuid,
+      number: plain.number,
+    });
+  }
+
+  static newFrom(meeting         ) {
+    return newFrom(meeting, Meeting);
+  }
+
+  constructor({ uuid, name, guestSipAuthorization, ownerUuids, port, hostname, number }         = {}) {
+    this.guestSipAuthorization = guestSipAuthorization;
+    this.hostname = hostname;
+    this.name = name;
+    this.ownerUuids = ownerUuids;
+    this.port = port;
+    this.uuid = uuid;
+    this.number = number;
+
+    // Useful to compare instead of instanceof with minified code
+    this.type = 'Meeting';
+  }
+
+  getGuestSipCredentials() {
+    // eslint-disable-next-line no-undef
+    const [username, secret] = atob(this.guestSipAuthorization).split(':');
+    return { username, secret };
+  }
+}
+
 /*       */
 
 var confdMethods = (client              , baseUrl        ) => ({
@@ -2570,6 +2635,18 @@ var confdMethods = (client              , baseUrl        ) => ({
       return null;
     }
   },
+
+  createMyMeeting: (name        )                   =>
+    client.post(`${baseUrl}/users/me/meetings`, { name }).then(Meeting.parse),
+
+  deleteMyMeeting: (meetingUuid        )                   =>
+    client.delete(`${baseUrl}/users/me/meetings/${meetingUuid}`, null),
+
+  getMeeting: (meetingUuid        )                   =>
+    client.get(`${baseUrl}/meetings/${meetingUuid}`, null).then(Meeting.parse),
+
+  guestGetMeeting: (meetingUuid        )                   =>
+    client.get(`${baseUrl}/guests/me/meetings/${meetingUuid}`, null).then(Meeting.parse),
 });
 
 //      
@@ -3327,7 +3404,7 @@ class CallSession {
     return newFrom(callSession, CallSession);
   }
 
-  static parseCall(session         , call      )              {
+  static parseCall(call      )              {
     return new CallSession({
       callId: call.id,
       sipCallId: call.sipCallId,
@@ -3512,7 +3589,11 @@ class CallLog {
       answered: plain.answered,
       callDirection: plain.call_direction,
       destination: {
-        extension: plain.requested_extension || plain.destination_extension,
+        // @TEMP: Temporarily assuming empty numbers are meetings
+        // which is admittedly a very dangerous assumption. Did i mention it was temporary?
+        extension: plain.requested_extension
+          || plain.destination_extension
+          || `meeting-${plain.requested_name || plain.destination_name || ''}`,
         name: plain.requested_name || plain.destination_name || '',
       },
       source: {
@@ -3528,27 +3609,11 @@ class CallLog {
   }
 
   static parseNew(plain                 , session         )          {
-    return new CallLog({
-      answer: plain.answer ? moment(plain.answer).toDate() : null,
-      answered: plain.answered,
-      callDirection: plain.call_direction,
-      destination: {
-        extension: plain.requested_extension || plain.destination_extension,
-        name: plain.requested_name || plain.destination_name || '',
-      },
-      source: {
-        extension: plain.source_extension,
-        name: plain.source_name,
-      },
-      id: plain.id,
-      duration: (plain.duration || 0) * 1000, // duration is in seconds
-      start: moment(plain.start).toDate(),
-      end: plain.end ? moment(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,
-    });
+    const callLog          = CallLog.parse(plain);
+    // @TODO: FIXME add verification declined vs missed call
+    callLog.newMissedCall = session
+      && session.hasExtension(plain.requested_extension || plain.destination_extension) && !plain.answered;
+    return callLog;
   }
 
   static newFrom(profile         ) {
@@ -3708,29 +3773,432 @@ class IndirectTransfer {
     });
   }
 
-  destinationIs(callSession             )          {
-    return callSession.isId(this.destinationId);
+  destinationIs(callSession             )          {
+    return callSession.isId(this.destinationId);
+  }
+
+  sourceIs(callSession             )          {
+    return callSession.isId(this.sourceId);
+  }
+
+  updateFrom(indirectTransfer                  ) {
+    updateFrom(this, indirectTransfer);
+  }
+
+  static newFrom(indirectTransfer                  ) {
+    return newFrom(indirectTransfer, 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';
+
+const logger$b = IssueReporter$1 ? IssueReporter$1.loggerFor('cti-phone') : console;
+
+class CTIPhone extends Emitter                  {
+                   
+
+                    
+
+                            
+
+                     
+
+  constructor(session         , isMobile          = false, callbackAllLines          = false) {
+    super();
+    logger$b.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$b.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$b.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$b.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$b.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$b.error('hangup CTI call, error', e);
+
+      this.eventEmitter.emit('onCallFailed', callSession);
+      return false;
+    }
+  }
+
+  ignore() {}
+
+  async reject(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$b.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$b.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$b.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$b.info('cancel CTI transfer', { transferId });
+
+    return CallApi.cancelCallTransfer(transferId);
+  }
+
+  async confirmCTIIndirectTransfer(transferId        )               {
+    logger$b.info('confirm CTI transfer', { transferId });
+
+    return CallApi.confirmCallTransfer(transferId);
+  }
+
+  sendKey(callSession             , digits        ) {
+    if (!callSession) {
+      return;
+    }
+    logger$b.info('send CTI key', { callId: callSession.getId(), number: callSession.number, digits });
+
+    return CallApi.sendDTMF(callSession.callId, digits);
+  }
+
+  onConnectionMade() {
+    logger$b.info('on CTI connection made');
+
+    this.eventEmitter.emit('onCallAccepted');
+  }
+
+  async close() {
+    logger$b.info('CTI close');
+
+    return Promise.resolve();
+  }
+
+  async hold(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$b.info('CTI hold', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.hold(callSession.callId);
+  }
+
+  async resume(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$b.info('CTI resume', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.resume(callSession.callId);
+  }
+
+  async mute(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$b.info('CTI mute', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.mute(callSession.callId);
+  }
+
+  async unmute(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$b.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;
   }
 
-  sourceIs(callSession             )          {
-    return callSession.isId(this.sourceId);
+  getRemoteStream() {
+    return null;
   }
 
-  updateFrom(indirectTransfer                  ) {
-    updateFrom(this, indirectTransfer);
+  getRemoteVideoStream() {
+    return null;
   }
 
-  static newFrom(indirectTransfer                  ) {
-    return newFrom(indirectTransfer, IndirectTransfer);
+  getRemoteAudioStream() {
+    return null;
   }
-}
-
-//      
-const TRANSFER_FLOW_BLIND = 'blind';
 
-// const MINIMUM_WAZO_ENGINE_VERSION_FOR_CTI_HOLD = '20.11';
+  hasLocalVideo() {
+    return false;
+  }
 
-IssueReporter$1 ? IssueReporter$1.loggerFor('cti-phone') : console;
+  useLocalVideoElement() {}
+}
 
 /*       */
 
@@ -4290,6 +4758,9 @@ var calldMethods = (client              , baseUrl        ) => ({
   getConferenceParticipantsAsUser: async (conferenceId        )                  =>
     client.get(`${baseUrl}/users/me/conferences/${conferenceId}/participants`),
 
+  getMeetingParticipantsAsUser: async (meetingUuid        )                  =>
+    client.get(`${baseUrl}/users/me/meetings/${meetingUuid}/participants`),
+
   listTrunks: () => client.get(`${baseUrl}/trunks`),
 
   mute: (callId        ) =>
@@ -4643,7 +5114,7 @@ const AGENTD_VERSION = '1.0';
 const WEBHOOKD_VERSION = '1.0';
 const AMID_VERSION = '1.0';
 
-const logger$9 = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
+const logger$a = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
 
 class ApiClient {
                        
@@ -4695,12 +5166,12 @@ class ApiClient {
   }
 
   async forceRefreshToken() {
-    logger$9.info('forcing refresh token, calling callback');
+    logger$a.info('forcing refresh token, calling callback');
     return this.refreshTokenCallback();
   }
 
   async refreshTokenCallback() {
-    logger$9.info('refresh token callback called', {
+    logger$a.info('refresh token callback called', {
       refreshToken: this.refreshToken,
       refreshBackend: this.refreshBackend,
       refreshExpiration: this.refreshExpiration,
@@ -4718,7 +5189,7 @@ class ApiClient {
       this.isMobile,
     );
 
-    logger$9.info('token refreshed', { token: session.token });
+    logger$a.info('token refreshed', { token: session.token });
 
     if (this.onRefreshToken) {
       this.onRefreshToken(session.token, session);
@@ -4859,7 +5330,7 @@ var getApiClient = (forServer         )                => {
 class InvalidSubscription extends Error {}
 class InvalidAuthorization extends Error {}
 
-const logger$8 = IssueReporter$1.loggerFor('simple-auth');
+const logger$9 = IssueReporter$1.loggerFor('simple-auth');
 
 class Auth {
                    
@@ -4894,7 +5365,7 @@ class Auth {
     setApiClientId(this.clientId);
     setRefreshExpiration(this.expiration);
     setOnRefreshToken((token        , session         ) => {
-      logger$8.info('on refresh token done', { token });
+      logger$9.info('on refresh token done', { token });
       setApiToken(token);
       Wazo.Websocket.updateToken(token);
 
@@ -5453,7 +5924,9 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
       .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
-          this.peerConnection.addTransceiver('video', { streams: [this._localMediaStream], direction: 'sendrecv' });
+          if (this.peerConnection.addTransceiver) {
+            this.peerConnection.addTransceiver('video', { streams: [this._localMediaStream], direction: 'sendrecv' });
+          }
         }
       })
       .then(() => this.createLocalOfferOrAnswer(options))
@@ -5480,12 +5953,6 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
         };
       })
       .then((sessionDescription) => this.applyModifiers(sessionDescription, modifiers))
-      .then((sessionDescription) => {
-        // Set new constraints to avoid the constraints check issue in `sdh.getLocalMediaStream` later.
-        this.localMediaStreamConstraints = options.constraints;
-
-        return sessionDescription;
-      })
       .then((sessionDescription) => ({ body: sessionDescription.sdp, contentType: 'application/sdp' }))
       .catch((error) => {
         wazoLogger.error('error when creating media', error);
@@ -5680,6 +6147,9 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
 
         // set the transceiver direction to the answer direction
         this._peerConnection.getTransceivers().forEach((transceiver) => {
+          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') {
@@ -5724,10 +6194,15 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
       if (kind !== 'audio' && kind !== 'video') {
         throw new Error(`Unknown new track kind ${kind}.`);
       }
-      const sender = pc.getSenders().find((otherSender) => otherSender.track && otherSender.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;
+        }
         trackUpdates.push(
           new Promise((resolve) => {
             this.logger.debug(`SessionDescriptionHandler.setLocalMediaStream - replacing sender ${kind} track`);
@@ -5761,7 +6236,11 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
             // Review: could make streamless tracks a configurable option?
             // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/addTrack#Usage_notes
             try {
-              pc.addTrack(newTrack, localStream);
+              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;
@@ -5897,7 +6376,7 @@ const DEFAULT_ICE_TIMEOUT = 3000;
 const SEND_STATS_DELAY = 5000;
 
 const states = ['STATUS_NULL', 'STATUS_NEW', 'STATUS_CONNECTING', 'STATUS_CONNECTED', 'STATUS_COMPLETED'];
-const logger$7 = IssueReporter$1 ? IssueReporter$1.loggerFor('webrtc-client') : console;
+const logger$8 = IssueReporter$1 ? IssueReporter$1.loggerFor('webrtc-client') : console;
 const statsLogger = IssueReporter$1 ? IssueReporter$1.loggerFor('webrtc-stats') : console;
 
 // events
@@ -5943,6 +6422,7 @@ const MAX_REGISTER_TRIES = 10;
                            
                          
                            
+                        
                         
   
 
@@ -5969,6 +6449,7 @@ class WebRTCClient extends Emitter {
                          
                                      
                                      
+                        
 
   // sugar
                         
@@ -6007,6 +6488,8 @@ class WebRTCClient extends Emitter {
     super();
     this.uaConfigOverrides = uaConfigOverrides;
     this.config = config;
+    this.skipRegister = config.skipRegister;
+
     this._buildConfig(config, session).then((newConfig              ) => {
       this.config = newConfig;
       this.userAgent = this.createUserAgent(uaConfigOverrides);
@@ -6062,13 +6545,13 @@ class WebRTCClient extends Emitter {
 
   createUserAgent(configOverrides         )            {
     const webRTCConfiguration = this._createWebRTCConfiguration(configOverrides);
-    logger$7.info('sdk webrtc, creating UA', { webRTCConfiguration });
+    logger$8.info('sdk webrtc, creating UA', { webRTCConfiguration });
 
     webRTCConfiguration.delegate = {
       onConnect: this.onConnect.bind(this),
       onDisconnect: this.onDisconnect.bind(this),
       onInvite: (invitation            ) => {
-        logger$7.info('sdk webrtc on invite', {
+        logger$8.info('sdk webrtc on invite', {
           method: 'delegate.onInvite',
           id: invitation.id,
           remoteURI: invitation.remoteURI,
@@ -6111,7 +6594,7 @@ class WebRTCClient extends Emitter {
   }
 
   onConnect() {
-    logger$7.info('sdk webrtc connected', { method: 'delegate.onConnect' });
+    logger$8.info('sdk webrtc connected', { method: 'delegate.onConnect' });
     this.eventEmitter.emit(CONNECTED);
     if (!this.isRegistered() && this.registerer && this.registerer.waiting) {
       this.registerer.waitingToggle(false);
@@ -6120,7 +6603,7 @@ class WebRTCClient extends Emitter {
   }
 
   async onDisconnect(error        ) {
-    logger$7.info('sdk webrtc disconnected', { method: 'delegate.onConnect', error });
+    logger$8.info('sdk webrtc disconnected', { method: 'delegate.onConnect', error });
     this.connectionPromise = null;
     // The UA will attempt to reconnect automatically when an error occurred
     this.eventEmitter.emit(DISCONNECTED, error);
@@ -6134,40 +6617,48 @@ class WebRTCClient extends Emitter {
   }
 
   register(tries         = 0)               {
-    logger$7.info('sdk webrtc registering...', {
+    const logInfo = {
       userAgent: !!this.userAgent,
       registered: this.isRegistered(),
       connectionPromise: !!this.connectionPromise,
       registerer: !!this.registerer,
       waiting: this.registerer && this.registerer.waiting,
       tries,
-    });
+      skipRegister: this.skipRegister,
+    };
+
+    if (this.skipRegister) {
+      logger$8.info('sdk webrtc skip register...', logInfo);
+      return Promise.resolve();
+    }
+
+    logger$8.info('sdk webrtc registering...', logInfo);
 
     if (!this.userAgent) {
-      logger$7.info('sdk webrtc recreating User Agent');
+      logger$8.info('sdk webrtc recreating User Agent');
       this.userAgent = this.createUserAgent(this.uaConfigOverrides);
     }
     if (!this.userAgent || this.isRegistered()) {
-      logger$7.info('sdk webrtc registering aborted, already registered or no UA can be created');
+      logger$8.info('sdk webrtc registering aborted, already registered or no UA can be created');
       return Promise.resolve();
     }
 
     if (this.connectionPromise || (this.registerer && this.registerer.waiting)) {
-      logger$7.info('sdk webrtc registering aborted due to a registration in progress.');
+      logger$8.info('sdk webrtc registering aborted due to a registration in progress.');
       return Promise.resolve();
     }
 
     const registerOptions = this._isWeb() ? {} : { extraContactHeaderParams: ['mobility=mobile'] };
 
     const onRegisterFailed = () => {
-      logger$7.info('sdk webrtc registering failed', { tries, registerer: !!this.registerer });
+      logger$8.info('sdk webrtc registering failed', { tries, registerer: !!this.registerer });
       this.connectionPromise = null;
       if (this.registerer && this.registerer.waiting) {
         this.registerer.waitingToggle(false);
       }
 
       if (tries <= MAX_REGISTER_TRIES) {
-        logger$7.info('sdk webrtc registering, retrying...', { tries });
+        logger$8.info('sdk webrtc registering, retrying...', { tries });
         setTimeout(() => this.register(tries + 1), 300);
       }
     };
@@ -6176,18 +6667,18 @@ class WebRTCClient extends Emitter {
       // Avoid race condition with the close method called just before register and setting userAgent to null
       // during the resolution of the primise.
       if (!this.userAgent) {
-        logger$7.info('sdk webrtc recreating User Agent after connection');
+        logger$8.info('sdk webrtc recreating User Agent after connection');
         this.userAgent = this.createUserAgent(this.uaConfigOverrides);
       }
 
-      logger$7.info('sdk webrtc registering, transport connected', { registerOptions, ua: !!this.userAgent });
+      logger$8.info('sdk webrtc registering, transport connected', { registerOptions, ua: !!this.userAgent });
       this.registerer = new Registerer(this.userAgent, registerOptions);
       this.connectionPromise = null;
       this._monkeyPatchRegisterer(this.registerer);
 
       // Bind registerer events
       this.registerer.stateChange.addListener(newState => {
-        logger$7.info('sdk webrtc registering, state changed', { newState });
+        logger$8.info('sdk webrtc registering, state changed', { newState });
 
         if (newState === RegistererState.Registered && this.registerer
           && this.registerer.state === RegistererState.Registered) {
@@ -6200,7 +6691,7 @@ class WebRTCClient extends Emitter {
       const options = {
         requestDelegate: {
           onReject: response => {
-            logger$7.error('sdk webrtc registering, rejected', { response });
+            logger$8.error('sdk webrtc registering, rejected', { response });
 
             onRegisterFailed();
           },
@@ -6208,13 +6699,13 @@ class WebRTCClient extends Emitter {
       };
 
       return this.registerer.register(options).catch((e) => {
-        logger$7.error('sdk webrtc registering, error', e);
+        logger$8.error('sdk webrtc registering, error', e);
 
         this.eventEmitter.emit(REGISTRATION_FAILED);
         return e;
       });
     }).catch(error => {
-      logger$7.error('sdk webrtc registering, transport error', error);
+      logger$8.error('sdk webrtc registering, transport error', error);
       onRegisterFailed();
     });
   }
@@ -6243,21 +6734,21 @@ class WebRTCClient extends Emitter {
   }
 
   unregister() {
-    logger$7.info('sdk webrtc unregistering..', { userAgent: !!this.userAgent, registerer: !!this.registerer });
+    logger$8.info('sdk webrtc unregistering..', { userAgent: !!this.userAgent, registerer: !!this.registerer });
     if (!this.registerer) {
       return Promise.resolve();
     }
 
     try {
       return this.registerer.unregister().then(() => {
-        logger$7.info('sdk webrtc unregistered');
+        logger$8.info('sdk webrtc unregistered');
         this._cleanupRegister();
       }).catch(e => {
-        logger$7.error('sdk webrtc unregistering, promise error', e);
+        logger$8.error('sdk webrtc unregistering, promise error', e);
         this._cleanupRegister();
       });
     } catch (e) {
-      logger$7.error('sdk webrtc unregistering, error', e);
+      logger$8.error('sdk webrtc unregistering, error', e);
       // Avoid issue with `undefined is not an object (evaluating 'new.target.prototype')` when triggering a new
       // error when the registerer is in a bad state
       this._cleanupRegister();
@@ -6265,7 +6756,7 @@ class WebRTCClient extends Emitter {
   }
 
   stop()               {
-    logger$7.info('sdk webrtc stop', { userAgent: !!this.userAgent });
+    logger$8.info('sdk webrtc stop', { userAgent: !!this.userAgent });
     if (!this.userAgent) {
       return Promise.resolve();
     }
@@ -6273,12 +6764,12 @@ class WebRTCClient extends Emitter {
     return this.userAgent.stop().then(() => {
       return this._cleanupRegister();
     }).catch(e => {
-      logger$7.warn('sdk webrtc stop, error', { message: e.message, stack: e.stack });
+      logger$8.warn('sdk webrtc stop, error', { message: e.message, stack: e.stack });
     });
   }
 
   call(number        , enableVideo          , audioOnly          = false, conference          = false)          {
-    logger$7.info('sdk webrtc creating call', { number, enableVideo, audioOnly });
+    logger$8.info('sdk webrtc creating call', { number, enableVideo, audioOnly });
     const inviterOptions         = {
       sessionDescriptionHandlerOptionsReInvite: {
         conference,
@@ -6307,7 +6798,7 @@ class WebRTCClient extends Emitter {
           this._onAccepted(session, response.session, true);
         },
         onReject: (response                  ) => {
-          logger$7.info('on call rejected', { id: session.id, fromTag: session.fromTag });
+          logger$8.info('on call rejected', { id: session.id, fromTag: session.fromTag });
           this._stopSendingStats(session);
 
           this.eventEmitter.emit(REJECTED, session, response);
@@ -6329,11 +6820,11 @@ class WebRTCClient extends Emitter {
   }
 
   answer(session            , enableVideo          ) {
-    logger$7.info('sdk webrtc answer call', { id: session.id, enableVideo });
+    logger$8.info('sdk webrtc answer call', { id: session.id, enableVideo });
 
     if (!session || !session.accept) {
       const error = 'No session to answer, or not an invitation';
-      logger$7.warn(error);
+      logger$8.warn(error);
       return Promise.reject(new Error(error));
     }
     const options = {
@@ -6343,15 +6834,15 @@ class WebRTCClient extends Emitter {
     return session.accept(options).then(() => {
       if (session.isCanceled) {
         const message = 'accepted a canceled session (or was canceled during the accept phase).';
-        logger$7.error(message, { id: session.id });
+        logger$8.error(message, { id: session.id });
         this.onCallEnded(session);
 
         throw new CanceledCallError(message);
       }
-      logger$7.info('sdk webrtc answer, accepted.');
+      logger$8.info('sdk webrtc answer, accepted.');
       this._onAccepted(session);
     }).catch(e => {
-      logger$7.error(`answer call error for ${session ? session.id : 'n/a'}`, e);
+      logger$8.error(`answer call error for ${session ? session.id : 'n/a'}`, e);
 
       throw e;
     });
@@ -6359,7 +6850,7 @@ class WebRTCClient extends Emitter {
 
   hangup(session         ) {
     const { state, id } = session;
-    logger$7.info('sdk webrtc hangup call', { id, state });
+    logger$8.info('sdk webrtc hangup call', { id, state });
 
     try {
       this._stopSendingStats(session);
@@ -6388,24 +6879,24 @@ class WebRTCClient extends Emitter {
 
       return bye();
     } catch (error) {
-      logger$7.warn('sdk webrtc hangup, error', error);
+      logger$8.warn('sdk webrtc hangup, error', error);
     }
 
     return null;
   }
 
   reject(session         ) {
-    logger$7.info('sdk webrtc reject call', { id: session.id });
+    logger$8.info('sdk webrtc reject call', { id: session.id });
 
     try {
       return session.reject ? session.reject() : session.cancel();
     } catch (e) {
-      logger$7.warn('Error when rejecting call', e.message, e.stack);
+      logger$8.warn('Error when rejecting call', e.message, e.stack);
     }
   }
 
   async close() {
-    logger$7.info('sdk webrtc closing client', { userAgent: !!this.userAgent });
+    logger$8.info('sdk webrtc closing client', { userAgent: !!this.userAgent });
     this._cleanupMedia();
     this.connectionPromise = null;
 
@@ -6436,7 +6927,7 @@ class WebRTCClient extends Emitter {
       // eg: "INVITE not rejectable in state Completed"
     }
     this.userAgent = null;
-    logger$7.info('sdk webrtc client closed');
+    logger$8.info('sdk webrtc client closed');
   }
 
   getNumber(session         )          {
@@ -6449,13 +6940,13 @@ class WebRTCClient extends Emitter {
   }
 
   mute(session         ) {
-    logger$7.info('sdk webrtc mute', { id: session.id });
+    logger$8.info('sdk webrtc mute', { id: session.id });
 
     this._toggleAudio(session, true);
   }
 
   unmute(session         ) {
-    logger$7.info('sdk webrtc unmute', { id: session.id });
+    logger$8.info('sdk webrtc unmute', { id: session.id });
 
     this._toggleAudio(session, false);
   }
@@ -6472,12 +6963,18 @@ class WebRTCClient extends Emitter {
     }
 
     if (pc.getSenders) {
+      if (!pc.getSenders().length) {
+        return false;
+      }
       pc.getSenders().forEach(sender => {
         if (sender && sender.track && sender.track.kind === 'audio') {
           muted = muted && !sender.track.enabled;
         }
       });
     } else {
+      if (!pc.getLocalStreams().length) {
+        return false;
+      }
       pc.getLocalStreams().forEach(stream => {
         stream.getAudioTracks().forEach(track => {
           muted = muted && !track.enabled;
@@ -6489,20 +6986,20 @@ class WebRTCClient extends Emitter {
   }
 
   toggleCameraOn(session         ) {
-    logger$7.info('sdk webrtc toggle camera on', { id: session.id });
+    logger$8.info('sdk webrtc toggle camera on', { id: session.id });
 
     this._toggleVideo(session, false);
   }
 
   toggleCameraOff(session         ) {
-    logger$7.info('sdk webrtc toggle camera off', { id: session.id });
+    logger$8.info('sdk webrtc toggle camera off', { id: session.id });
 
     this._toggleVideo(session, true);
   }
 
   hold(session         , isConference          = false) {
     const sessionId = this.getSipSessionId(session);
-    logger$7.info('sdk webrtc hold', {
+    logger$8.info('sdk webrtc hold', {
       sessionId,
       keys: Object.keys(this.heldSessions),
       pendingReinvite: !!session.pendingReinvite,
@@ -6534,6 +7031,9 @@ class WebRTCClient extends Emitter {
     if (!this._isWeb()) {
       options.sessionDescriptionHandlerModifiers = [holdModifier];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -6542,7 +7042,7 @@ class WebRTCClient extends Emitter {
   unhold(session         , isConference          = false) {
     const sessionId = this.getSipSessionId(session);
 
-    logger$7.info('sdk webrtc unhold', {
+    logger$8.info('sdk webrtc unhold', {
       sessionId,
       keys: Object.keys(this.heldSessions),
       pendingReinvite: !!session.pendingReinvite,
@@ -6573,6 +7073,9 @@ class WebRTCClient extends Emitter {
       // (eg: holdModifier)
       options.sessionDescriptionHandlerModifiers = [];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -6630,7 +7133,7 @@ class WebRTCClient extends Emitter {
       return;
     }
 
-    logger$7.info('send WebRTC message', { sipId: sipSession.id, contentType });
+    logger$8.info('send WebRTC message', { sipId: sipSession.id, contentType });
 
     try {
       sipSession.message({
@@ -6755,7 +7258,8 @@ class WebRTCClient extends Emitter {
     }
     const sdh = session.sessionDescriptionHandler;
     const pc = sdh.peerConnection;
-    const localStream = this.getLocalStream(this.getSipSessionId(session));
+    const sessionId = this.getSipSessionId(session);
+    const localStream = this.getLocalStream(sessionId);
 
     // Release old video stream
     if (localStream) {
@@ -6781,11 +7285,8 @@ class WebRTCClient extends Emitter {
 
       // let's update the local stream
       this.eventEmitter.emit('onVideoInputChange', stream);
-      try {
-        await sdh.setLocalMediaStream(stream);
-      } catch (_) {
-        // Nothing to do
-      }
+      this.setLocalMediaStream(sessionId, stream);
+
       return stream;
     });
   }
@@ -6997,7 +7498,7 @@ class WebRTCClient extends Emitter {
   }
 
   startHeartbeat() {
-    logger$7.info('sdk webrtc start heartbeat', { userAgent: !!this.userAgent });
+    logger$8.info('sdk webrtc start heartbeat', { userAgent: !!this.userAgent });
     if (!this.userAgent) {
       this.heartbeat.stop();
       return;
@@ -7010,7 +7511,7 @@ class WebRTCClient extends Emitter {
   }
 
   stopHeartbeat() {
-    logger$7.info('sdk webrtc stop heartbeat');
+    logger$8.info('sdk webrtc stop heartbeat');
     this.heartbeat.stop();
   }
 
@@ -7030,7 +7531,7 @@ class WebRTCClient extends Emitter {
   }
 
   attemptReconnection()       {
-    logger$7.info('attempt reconnection', { userAgent: !!this.userAgent });
+    logger$8.info('attempt reconnection', { userAgent: !!this.userAgent });
     if (!this.userAgent) {
       return;
     }
@@ -7087,9 +7588,11 @@ class WebRTCClient extends Emitter {
       remoteStream.removeTrack(track);
     });
 
-    pc.getReceivers().forEach(receiver => {
-      remoteStream.addTrack(receiver.track);
-    });
+    if (pc.getReceivers) {
+      pc.getReceivers().forEach(receiver => {
+        remoteStream.addTrack(receiver.track);
+      });
+    }
   }
 
   getMediaConfiguration(enableVideo         , conference          = false, constraints          = null)         {
@@ -7124,6 +7627,25 @@ class WebRTCClient extends Emitter {
     return sessionId in this.conferences;
   }
 
+  createAudioElementFor(sessionId        ) {
+    const audio      = document.createElement('audio');
+    audio.setAttribute('id', `audio-${sessionId}`);
+
+    if (audio.setSinkId && this.audioOutputDeviceId) {
+      audio.setSinkId(this.audioOutputDeviceId);
+    }
+
+    if (document.body) {
+      document.body.appendChild(audio);
+    }
+    this.audioElements[sessionId] = audio;
+
+    audio.volume = this.audioOutputVolume;
+    audio.autoplay = true;
+
+    return audio;
+  }
+
   _onTransportError() {
     this.eventEmitter.emit(TRANSPORT_ERROR);
     this.attemptReconnection();
@@ -7133,7 +7655,7 @@ class WebRTCClient extends Emitter {
     const body = message && typeof message === 'object' ? message.data : message;
     if (body && body.indexOf('200 OK') !== -1) {
       if (this.hasHeartbeat()) {
-        logger$7.info('on heartbeat received from Asterisk', { hasHeartbeat: this.hasHeartbeat() });
+        logger$8.info('on heartbeat received from Asterisk', { hasHeartbeat: this.hasHeartbeat() });
 
         this.heartbeat.onHeartbeat();
         if (this.heartbeatCb) {
@@ -7144,7 +7666,7 @@ class WebRTCClient extends Emitter {
   }
 
   async _onHeartbeatTimeout() {
-    logger$7.info('sdk webrtc heartbeat timed out', { userAgent: !!this.userAgent, cb: !!this.heartbeatTimeoutCb });
+    logger$8.info('sdk webrtc heartbeat timed out', { userAgent: !!this.userAgent, cb: !!this.heartbeatTimeoutCb });
 
     if (this.heartbeatTimeoutCb) {
       this.heartbeatTimeoutCb();
@@ -7156,7 +7678,7 @@ class WebRTCClient extends Emitter {
         try {
           await this.userAgent.transport.disconnect();
         } catch (e) {
-          logger$7.error('Transport disconnection after heartbeat timeout, error', e);
+          logger$8.error('Transport disconnection after heartbeat timeout, error', e);
         }
       }
 
@@ -7189,31 +7711,31 @@ class WebRTCClient extends Emitter {
   }
 
   _connectIfNeeded()                {
-    logger$7.info('connect if needed, checking', { connected: this.isConnected() });
+    logger$8.info('connect if needed, checking', { connected: this.isConnected() });
     if (!this.userAgent) {
-      logger$7.info('need to recreate User Agent');
+      logger$8.info('need to recreate User Agent');
       this.userAgent = this.createUserAgent(this.uaConfigOverrides);
     }
 
     if (this.isConnected()) {
-      logger$7.info('webrtc sdk, already connected');
+      logger$8.info('webrtc sdk, already connected');
       return Promise.resolve();
     }
 
     if (this.isConnecting()) {
-      logger$7.info('webrtc sdk, already connecting...');
+      logger$8.info('webrtc sdk, already connecting...');
 
       this.connectionPromise = this.userAgent.transport.connectPromise;
       return this.connectionPromise;
     }
 
     if (this.connectionPromise) {
-      logger$7.info('webrtc sdk, connection promise connecting...');
+      logger$8.info('webrtc sdk, connection promise connecting...');
       // $FlowFixMe
       return this.connectionPromise;
     }
 
-    logger$7.info('WebRTC UA needs to connect');
+    logger$8.info('WebRTC UA needs to connect');
 
     // Force UA to reconnect
     if (this.userAgent && this.userAgent.state !== UserAgentState.Stopped) {
@@ -7338,7 +7860,7 @@ class WebRTCClient extends Emitter {
 
       sdh.peerConnectionDelegate = {
         onicecandidateerror: (error        ) => {
-          logger$7.error('on icecandidate error', {
+          logger$8.error('on icecandidate error', {
             address: error.address,
             port: error.port,
             errorCode: error.errorCode,
@@ -7353,7 +7875,7 @@ class WebRTCClient extends Emitter {
     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
+    // Because when `onInvite` is called we already got the video track
     session.onInviteRequest = (request) => {
       hadRemoteVideo = this.hasARemoteVideoTrack(sipSessionId);
 
@@ -7367,7 +7889,7 @@ class WebRTCClient extends Emitter {
         updatedNumber = session.assertedIdentity.uri.normal.user;
         updatedCalleeName = session.assertedIdentity.displayName || updatedNumber;
       }
-      logger$7.info('re-invite received', { updatedCalleeName, updatedNumber });
+      logger$8.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
 
@@ -7388,7 +7910,7 @@ class WebRTCClient extends Emitter {
   }
 
   _onAccepted(session         , sessionDialog                , withEvent          = true) {
-    logger$7.info('on call accepted', { id: session.id, remoteTag: session.remoteTag });
+    logger$8.info('on call accepted', { id: session.id, remoteTag: session.remoteTag });
 
     this.storeSipSession(session);
 
@@ -7428,20 +7950,10 @@ class WebRTCClient extends Emitter {
     const isConference = this.isConference(sessionId);
 
     if (this._hasAudio() && this._isWeb() && !(sessionId in this.audioElements)) {
-      const audio      = document.createElement('audio');
-      audio.setAttribute('id', `audio-${sessionId}`);
-
-      if (audio.setSinkId && this.audioOutputDeviceId) {
-        audio.setSinkId(this.audioOutputDeviceId);
-      }
-
-      if (document.body) {
-        document.body.appendChild(audio);
-      }
-      this.audioElements[sessionId] = audio;
+      this.createAudioElementFor(sessionId);
     }
 
-    const audioElement = this.audioElements[this.getSipSessionId(session)];
+    const audioElement = this.audioElements[sessionId];
     const stream = newStream || this.getRemoteStream(sessionId);
 
     if (!this._isWeb() || !stream) {
@@ -7588,10 +8100,10 @@ class WebRTCClient extends Emitter {
 
   _stopSendingStats(session         ) {
     const sessionId = this.getSipSessionId(session);
-    logger$7.trace('Check for stopping stats', { sessionId, ids: Object.keys(this.statsIntervals) });
+    logger$8.trace('Check for stopping stats', { sessionId, ids: Object.keys(this.statsIntervals) });
 
     if (sessionId in this.statsIntervals) {
-      logger$7.trace('Stop sending stats for call', { sessionId });
+      logger$8.trace('Stop sending stats for call', { sessionId });
       this.statsIntervals[sessionId]();
       delete this.statsIntervals[sessionId];
     }
@@ -7607,7 +8119,7 @@ class WebRTCClient extends Emitter {
       try {
         await this.userAgent.transport.disconnect();
       } catch (e) {
-        logger$7.error('WebRTC transport disconnect, error', e);
+        logger$8.error('WebRTC transport disconnect, error', e);
       }
     }
   }
@@ -7694,7 +8206,7 @@ const events = [
   ON_SIGNAL,
 ];
 
-const logger$6 = IssueReporter$1.loggerFor('webrtc-phone');
+const logger$7 = IssueReporter$1.loggerFor('webrtc-phone');
 
 class WebRTCPhone extends Emitter                  {
                            
@@ -7765,7 +8277,7 @@ class WebRTCPhone extends Emitter                  {
     }).catch(error => {
       // Avoid exception on `t.server.scheme` in sip transport when losing the webrtc socket connection
       console.error('register error', error, error.message, error.stack);
-      logger$6.error('WebRTC register error', { message: error.message, stack: error.stack });
+      logger$7.error('WebRTC register error', { message: error.message, stack: error.stack });
     });
   }
 
@@ -7780,7 +8292,7 @@ class WebRTCPhone extends Emitter                  {
     if (!this.client) {
       return;
     }
-    logger$6.info('WebRTC phone stop');
+    logger$7.info('WebRTC phone stop');
     this.client.stop();
   }
 
@@ -7795,14 +8307,14 @@ class WebRTCPhone extends Emitter                  {
   async sendReinvite(callSession              , constraints          = null, conference          = false,
     audioOnly          = false) {
     const sipSession = this.findSipSession(callSession);
-    logger$6.info('WebRTC phone - send reinvite', {
+    logger$7.info('WebRTC phone - send reinvite', {
       sessionId: sipSession ? sipSession.id : null,
       constraints,
       audioOnly,
     });
 
     if (!sipSession) {
-      return null;
+      return false;
     }
 
     // $FlowFixMe
@@ -7812,19 +8324,17 @@ class WebRTCPhone extends Emitter                  {
     // Downgrade
     if (constraints && !isUpgrade) {
       // No reinvite needed
-      return this._downgradeToAudio(callSession);
+      this._downgradeToAudio(callSession);
+      return false;
     }
 
     if (isUpgrade) {
       const shouldReinvite = await this._upgradeToVideo(callSession, constraints, conference);
       if (!shouldReinvite) {
-        return;
+        return false;
       }
     }
 
-    // Force reinvite in SDH
-    sipSession.sessionDescriptionHandler.localMediaStreamConstraints = null;
-
     return this.client.reinvite(sipSession, constraints, conference, audioOnly);
   }
 
@@ -7833,7 +8343,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   startHeartbeat() {
-    logger$6.info('WebRTC phone - start heartbeat', { client: !!this.client, hasHeartbeat: this.client.hasHeartbeat() });
+    logger$7.info('WebRTC phone - start heartbeat', { client: !!this.client, hasHeartbeat: this.client.hasHeartbeat() });
     if (!this.client || this.client.hasHeartbeat()) {
       return;
     }
@@ -7842,7 +8352,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   stopHeartbeat() {
-    logger$6.info('WebRTC phone - stopHeartbeat', { client: !!this.client });
+    logger$7.info('WebRTC phone - stopHeartbeat', { client: !!this.client });
     if (!this.client) {
       return;
     }
@@ -7859,7 +8369,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   reconnect() {
-    logger$6.info('WebRTC phone - reconnect', { client: !!this.client });
+    logger$7.info('WebRTC phone - reconnect', { client: !!this.client });
     if (!this.client) {
       return;
     }
@@ -7897,7 +8407,7 @@ class WebRTCPhone extends Emitter                  {
   _downgradeToAudio(callSession              ) {
     const sipSession = this.findSipSession(callSession);
     if (!sipSession) {
-      return;
+      return false;
     }
 
     // Release local video stream when downgrading to audio
@@ -8010,7 +8520,7 @@ class WebRTCPhone extends Emitter                  {
       // Monkey patch to know when canceled with the CANCEL message
       const onCancel = sipSession._onCancel.bind(sipSession);
       sipSession._onCancel = (message                        ) => {
-        logger$6.trace('on sip session canceled', { callId: message.callId });
+        logger$7.trace('on sip session canceled', { callId: message.callId });
 
         onCancel(message);
         const elsewhere = message.data.indexOf('cause=26') !== -1 && message.data.indexOf('completed elsewhere') !== -1;
@@ -8035,13 +8545,13 @@ class WebRTCPhone extends Emitter                  {
             this.audioOutputVolume,
           );
         case SessionState.Terminating:
-          logger$6.info('WebRTC phone - call terminating', { sipId: sipSession.id });
+          logger$7.info('WebRTC phone - call terminating', { sipId: sipSession.id });
 
           this.eventEmitter.emit(ON_CALL_ENDING, this._createCallSession(sipSession));
 
           break;
         case SessionState.Terminated:
-          logger$6.info('WebRTC phone - call terminated', { sipId: sipSession.id });
+          logger$7.info('WebRTC phone - call terminated', { sipId: sipSession.id });
 
           this._onCallTerminated(sipSession);
 
@@ -8077,7 +8587,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   async startScreenSharing(constraints        , callSession              ) {
-    logger$6.info('WebRTC - start screen sharing', { constraints, id: callSession ? callSession.getId() : null });
+    logger$7.info('WebRTC - start screen sharing', { constraints, id: callSession ? callSession.getId() : null });
 
     const screenShareStream = await this._getStreamFromConstraints(constraints);
     if (!screenShareStream) {
@@ -8099,6 +8609,10 @@ class WebRTCPhone extends Emitter                  {
       localStream.removeTrack(videoTrack);
     }
 
+    if (localStream) {
+      localStream.addTrack(screenTrack);
+    }
+
     if (sender) {
       sender.replaceTrack(screenTrack);
     }
@@ -8113,7 +8627,8 @@ class WebRTCPhone extends Emitter                  {
       return;
     }
 
-    logger$6.info('WebRTC phone - stop screen sharing');
+    logger$7.info('WebRTC phone - stop screen sharing');
+    let reinvited = false;
 
     try {
       if (this.currentScreenShare.stream) {
@@ -8128,7 +8643,8 @@ class WebRTCPhone extends Emitter                  {
         // 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);
+        const constraints = { audio: false, video: screenshareStopped };
+        reinvited = await this.sendReinvite(targetCallSession, constraints, conference);
       }
     } catch (e) {
       console.warn(e);
@@ -8142,6 +8658,8 @@ class WebRTCPhone extends Emitter                  {
     );
 
     this.currentScreenShare = null;
+
+    return reinvited;
   }
 
   async _getStreamFromConstraints(constraints        , conference          = false)                        {
@@ -8179,7 +8697,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   _onCallAccepted(sipSession         , cameraEnabled         )              {
-    logger$6.info('WebRTC phone -  on call accepted', { sipId: sipSession.id, cameraEnabled });
+    logger$7.info('WebRTC phone -  on call accepted', { sipId: sipSession.id, cameraEnabled });
 
     const callSession = this._createAcceptedCallSession(sipSession, cameraEnabled);
     this.currentSipSession = sipSession;
@@ -8197,11 +8715,15 @@ class WebRTCPhone extends Emitter                  {
   }
 
   changeAudioDevice(id        ) {
-    logger$6.info('WebRTC phone - change audio device', { deviceId: id });
+    logger$7.info('WebRTC phone - change audio device', { deviceId: id });
     this.audioOutputDeviceId = id;
     this.client.changeAudioOutputDevice(id);
   }
 
+  createAudioElementFor(sessionId        ) {
+    return this.client.createAudioElementFor(sessionId);
+  }
+
   changeRingDevice(id        ) {
     this.audioRingDeviceId = id;
   }
@@ -8218,25 +8740,25 @@ class WebRTCPhone extends Emitter                  {
   }
 
   changeAudioInputDevice(id        ) {
-    logger$6.info('WebRTC phone - changeAudio input device', { deviceId: id });
+    logger$7.info('WebRTC phone - changeAudio input device', { deviceId: id });
 
     return this.client.changeAudioInputDevice(id, this.currentSipSession);
   }
 
   changeVideoInputDevice(id         ) {
-    logger$6.info('WebRTC phone - change video input device', { deviceId: id });
+    logger$7.info('WebRTC phone - change video input device', { deviceId: id });
 
     return this.client.changeVideoInputDevice(id, this.currentSipSession);
   }
 
   changeSessionVideoInputDevice(id         ) {
-    logger$6.info('WebRTC phone - change session video input device', { deviceId: id });
+    logger$7.info('WebRTC phone - change session video input device', { deviceId: id });
 
     return this.client.changeSessionVideoInputDevice(id, this.currentSipSession);
   }
 
   _onCallTerminated(sipSession         ) {
-    logger$6.info('WebRTC phone - on call terminated', { sipId: sipSession.id });
+    logger$7.info('WebRTC phone - on call terminated', { sipId: sipSession.id });
 
     const callSession = this._createCallSession(sipSession);
     const isCurrentSession = this.isCurrentCallSipSession(callSession);
@@ -8270,7 +8792,7 @@ class WebRTCPhone extends Emitter                  {
     const hasIncomingCallSession = this.hasIncomingCallSession();
 
     // Re-trigger incoming call event for remaining incoming calls
-    logger$6.info('WebRTC phone - check to re-trigger incoming call', {
+    logger$7.info('WebRTC phone - check to re-trigger incoming call', {
       sipId: sipSession.id,
       shouldRetrigger,
       hasIncomingCallSession,
@@ -8359,37 +8881,37 @@ class WebRTCPhone extends Emitter                  {
 
   // Deprecated
   getLocalStreamForCall(callSession             )               {
-    logger$6.warn('WebRTCPhone.getLocalStreamForCall is deprecated, use WebRTCPhone.getLocalStream instead');
+    logger$7.warn('WebRTCPhone.getLocalStreamForCall is deprecated, use WebRTCPhone.getLocalStream instead');
 
     return this.getLocalStream(callSession);
   }
 
   // Deprecated
   getRemoteStreamForCall(callSession             )               {
-    logger$6.warn('WebRTCPhone.getRemoteStreamForCall is deprecated, use WebRTCPhone.getRemoteStream instead');
+    logger$7.warn('WebRTCPhone.getRemoteStreamForCall is deprecated, use WebRTCPhone.getRemoteStream instead');
 
     return this.getRemoteVideoStream(callSession);
   }
 
   getRemoteStreamsForCall(callSession             )               {
-    logger$6.warn('WebRTCPhone.getRemoteStreamsForCall is deprecated, use WebRTCPhone.getRemoteStreams instead');
+    logger$7.warn('WebRTCPhone.getRemoteStreamsForCall is deprecated, use WebRTCPhone.getRemoteStreams instead');
 
     return this.getRemoteStream(callSession);
   }
 
   accept(callSession             , cameraEnabled          )                         {
-    logger$6.info('WebRTC phone - accept call', { id: callSession ? callSession.getId() : 'n/a', cameraEnabled });
+    logger$7.info('WebRTC phone - accept call', { id: callSession ? callSession.getId() : 'n/a', cameraEnabled });
     if (this.currentSipSession) {
       this.holdSipSession(this.currentSipSession, this.currentCallSession, true);
     }
 
     if (!callSession) {
-      logger$6.warn('no CallSession to accept.');
+      logger$7.warn('no CallSession to accept.');
       return Promise.resolve(null);
     }
 
     if (callSession.getId() in this.acceptedSessions) {
-      logger$6.warn('CallSession already accepted.', { id: callSession ? callSession.getId() : 'n/a' });
+      logger$7.warn('CallSession already accepted.', { id: callSession ? callSession.getId() : 'n/a' });
       return Promise.resolve(callSession.sipCallId);
     }
 
@@ -8401,24 +8923,24 @@ class WebRTCPhone extends Emitter                  {
     const sipSession = this.client.getSipSession(callSession.getId());
     if (sipSession) {
       if (sipSession.state === SessionState.Terminated || sipSession.state === SessionState.Terminating) {
-        logger$6.warn('Trying to answer a terminated sipSession.');
+        logger$7.warn('Trying to answer a terminated sipSession.');
 
         return Promise.resolve(null);
       }
 
-      logger$6.info('accept call, session found', { sipId: sipSession.id });
+      logger$7.info('accept call, session found', { sipId: sipSession.id });
 
       // $FlowFixMe
       return this.client.answer(sipSession, this.allowVideo ? cameraEnabled : false).then(() => {
         return callSession.sipCallId;
       }).catch(e => {
-        logger$6.error(e);
+        logger$7.error(e);
         this.endCurrentCall(callSession);
         throw e;
       });
     }
 
-    logger$6.warn('no CallSession found to accept.', { id: callSession ? callSession.getId() : 'n/a' });
+    logger$7.warn('no CallSession found to accept.', { id: callSession ? callSession.getId() : 'n/a' });
 
     return Promise.resolve(null);
   }
@@ -8428,7 +8950,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   async reject(callSession             )                {
-    logger$6.info('reject WebRTC called', { id: callSession.getId() });
+    logger$7.info('reject WebRTC called', { id: callSession.getId() });
 
     this.eventEmitter.emit(ON_TERMINATE_SOUND, callSession, 'call rejected locally');
     if (!callSession || callSession.getId() in this.rejectedSessions) {
@@ -8440,14 +8962,14 @@ class WebRTCPhone extends Emitter                  {
 
     const sipSession = this.findSipSession(callSession);
     if (sipSession) {
-      logger$6.info('WebRTC rejecting', { sipId: sipSession.id });
+      logger$7.info('WebRTC rejecting', { sipId: sipSession.id });
 
       this.client.hangup(sipSession);
     }
   }
 
   async ignore(callSession             )                {
-    logger$6.info('WebRTC ignore', { id: callSession.getId() });
+    logger$7.info('WebRTC ignore', { id: callSession.getId() });
 
     // kill the ring
     this.eventEmitter.emit(ON_TERMINATE_SOUND, callSession, 'ignoring call');
@@ -8456,7 +8978,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   hold(callSession             , withEvent          = true, isConference          = false)       {
-    logger$6.info('WebRTC hold', { id: callSession.getId() });
+    logger$7.info('WebRTC hold', { id: callSession.getId() });
 
     const sipSession = this.findSipSession(callSession);
 
@@ -8467,7 +8989,7 @@ class WebRTCPhone extends Emitter                  {
 
   // @Deprecated
   unhold(callSession             , withEvent          = true, isConference          = false)       {
-    logger$6.info('WebRTC unhold', { id: callSession ? callSession.getId() : null });
+    logger$7.info('WebRTC unhold', { id: callSession ? callSession.getId() : null });
 
     console.warn('Please note that `phone.unhold()` is being deprecated; `phone.resume()` is the preferred method');
 
@@ -8482,7 +9004,7 @@ class WebRTCPhone extends Emitter                  {
     const sipSession = this.findSipSession(callSession);
 
     if (sipSession) {
-      logger$6.info('WebRTC atxfer', { sipId: sipSession.id });
+      logger$7.info('WebRTC atxfer', { sipId: sipSession.id });
 
       return this.client.atxfer(sipSession);
     }
@@ -8497,7 +9019,7 @@ class WebRTCPhone extends Emitter                  {
     if (!sipSession) {
       return new Promise((resolve, reject) => reject(new Error('No session to hold')));
     }
-    logger$6.info('WebRTC hold sip session', { sipId: sipSession.id });
+    logger$7.info('WebRTC hold sip session', { sipId: sipSession.id });
 
     const promise = this.client.hold(sipSession, isConference);
     if (withEvent) {
@@ -8516,7 +9038,7 @@ class WebRTCPhone extends Emitter                  {
     if (!sipSession) {
       return new Promise((resolve, reject) => reject(new Error('No session to unhold')));
     }
-    logger$6.info('WebRTC unhold', { sipId: sipSession.id });
+    logger$7.info('WebRTC unhold', { sipId: sipSession.id });
 
     const promise = this.client.unhold(sipSession, isConference);
     if (withEvent) {
@@ -8527,18 +9049,18 @@ class WebRTCPhone extends Emitter                  {
   }
 
   resume(callSession              , isConference          = false)               {
-    logger$6.info('WebRTC resume called', { id: callSession ? callSession.getId() : null });
+    logger$7.info('WebRTC resume called', { id: callSession ? callSession.getId() : null });
 
     const sipSession = this.findSipSession(callSession);
     if (!sipSession) {
       return new Promise((resolve, reject) => reject(new Error('No session to resume')));
     }
 
-    logger$6.info('WebRTC resuming', { sipId: sipSession.id });
+    logger$7.info('WebRTC resuming', { sipId: sipSession.id });
 
     // Hold current session if different from the current one (we don't want 2 sessions active at the same time).
     if (this.currentSipSession && this.currentSipSession.id !== sipSession.id) {
-      logger$6.info('WebRTC hold call after resume', { id: this.currentSipSession.id });
+      logger$7.info('WebRTC hold call after resume', { id: this.currentSipSession.id });
       this.holdSipSession(this.currentSipSession, callSession);
     }
 
@@ -8553,14 +9075,14 @@ class WebRTCPhone extends Emitter                  {
   }
 
   mute(callSession              , withEvent          = true)       {
-    logger$6.info('WebRTC mute called', { id: callSession ? callSession.getId() : null });
+    logger$7.info('WebRTC mute called', { id: callSession ? callSession.getId() : null });
 
     const sipSession = this.findSipSession(callSession);
     if (!sipSession) {
       return;
     }
 
-    logger$6.info('WebRTC muting', { sipId: sipSession.id });
+    logger$7.info('WebRTC muting', { sipId: sipSession.id });
     this.client.mute(sipSession);
     const newCallSession = this._createCallSession(sipSession, callSession, { muted: true });
 
@@ -8574,14 +9096,14 @@ class WebRTCPhone extends Emitter                  {
   }
 
   unmute(callSession              , withEvent          = true)       {
-    logger$6.info('WebRTC unmute called', { id: callSession ? callSession.getId() : null });
+    logger$7.info('WebRTC unmute called', { id: callSession ? callSession.getId() : null });
 
     const sipSession = this.findSipSession(callSession);
     if (!sipSession) {
       return;
     }
 
-    logger$6.info('WebRTC unmuting', { sipId: sipSession.id });
+    logger$7.info('WebRTC unmuting', { sipId: sipSession.id });
     this.client.unmute(sipSession);
     const newCallSession = this._createCallSession(sipSession, callSession, { muted: false });
 
@@ -8608,7 +9130,7 @@ class WebRTCPhone extends Emitter                  {
     if (!sipSession) {
       return;
     }
-    logger$6.info('WebRTC turn camera on', { sipId: sipSession.id });
+    logger$7.info('WebRTC turn camera on', { sipId: sipSession.id });
 
     this.client.toggleCameraOn(sipSession);
 
@@ -8620,7 +9142,7 @@ class WebRTCPhone extends Emitter                  {
     if (!sipSession) {
       return;
     }
-    logger$6.info('WebRTC turn camera off', { sipId: sipSession.id });
+    logger$7.info('WebRTC turn camera off', { sipId: sipSession.id });
 
     this.client.toggleCameraOff(sipSession);
     this.eventEmitter.emit(ON_CAMERA_DISABLED, this._createCameraDisabledCallSession(sipSession, callSession));
@@ -8632,7 +9154,7 @@ class WebRTCPhone extends Emitter                  {
       return;
     }
 
-    logger$6.info('WebRTC send key', { sipId: sipSession.id, tone });
+    logger$7.info('WebRTC send key', { sipId: sipSession.id, tone });
     this.client.sendDTMF(sipSession, tone);
   }
 
@@ -8640,7 +9162,7 @@ class WebRTCPhone extends Emitter                  {
   // @TODO: line is not used here
   async makeCall(number        , line     , cameraEnabled          ,
     audioOnly          = false, conference          = false)                        {
-    logger$6.info('make WebRTC call', { number, lineId: line ? line.id : null, cameraEnabled });
+    logger$7.info('make WebRTC call', { number, lineId: line ? line.id : null, cameraEnabled });
     if (!number) {
       return Promise.resolve(null);
     }
@@ -8650,7 +9172,7 @@ class WebRTCPhone extends Emitter                  {
     }
     if (this.currentSipSession) {
       this.holdSipSession(this.currentSipSession, this.currentCallSession, true).catch(e => {
-        logger$6.warn('Unable to hold current session when making another call', e);
+        logger$7.warn('Unable to hold current session when making another call', e);
       });
     }
 
@@ -8660,7 +9182,7 @@ class WebRTCPhone extends Emitter                  {
       this._bindEvents(sipSession);
     } catch (error) {
       console.warn(error);
-      logger$6.warn('make WebRTC call, error', { message: error.message, stack: error.stack });
+      logger$7.warn('make WebRTC call, error', { message: error.message, stack: error.stack });
       return Promise.resolve(null);
     }
     const callSession = this._createOutgoingCallSession(sipSession, cameraEnabled || false);
@@ -8688,7 +9210,7 @@ class WebRTCPhone extends Emitter                  {
       return;
     }
 
-    logger$6.info('WebRTC transfer', { sipId: sipSession.id, target });
+    logger$7.info('WebRTC transfer', { sipId: sipSession.id, target });
 
     this.client.transfer(sipSession, target);
   }
@@ -8697,7 +9219,7 @@ class WebRTCPhone extends Emitter                  {
     const sipSession = this.client.getSipSession(source.sipCallId);
     const sipSessionTarget = this.client.getSipSession(destination.sipCallId);
 
-    logger$6.info('WebRTC indirect transfer', {
+    logger$7.info('WebRTC indirect transfer', {
       sipId: sipSession ? sipSession.id : null,
       target: sipSessionTarget ? sipSessionTarget.id : null,
     });
@@ -8725,7 +9247,7 @@ class WebRTCPhone extends Emitter                  {
       return false;
     }
 
-    logger$6.info('WebRTC hangup', { sipId: sipSession.id });
+    logger$7.info('WebRTC hangup', { sipId: sipSession.id });
 
     const sipSessionId = this.getSipSessionId(sipSession);
 
@@ -8770,7 +9292,7 @@ class WebRTCPhone extends Emitter                  {
   }
 
   async close()                {
-    logger$6.info('WebRTC close');
+    logger$7.info('WebRTC close');
 
     try {
       await Promise.race([
@@ -8778,7 +9300,7 @@ class WebRTCPhone extends Emitter                  {
         new Promise((resolve, reject) => setTimeout(() => reject(new Error('Unregister, timed out')), 3000)),
       ]);
     } catch (e) {
-      logger$6.error('WebRTC close, unregister error', e);
+      logger$7.error('WebRTC close, unregister error', e);
     }
 
     this.client.close();
@@ -8796,12 +9318,12 @@ class WebRTCPhone extends Emitter                  {
   }
 
   enableRinging()                       {
-    logger$6.info('WebRTC enable ringing');
+    logger$7.info('WebRTC enable ringing');
     this.ringingEnabled = true;
   }
 
   disableRinging()                       {
-    logger$6.info('WebRTC disable ringing');
+    logger$7.info('WebRTC disable ringing');
     this.ringingEnabled = false;
   }
 
@@ -8841,7 +9363,7 @@ class WebRTCPhone extends Emitter                  {
 
   // Deprecated
   getLocalMediaStream(callSession             ) {
-    logger$6.warn('WebRTCPhone.getLocalMediaStream is deprecated, use WebRTCPhone.getLocalStream instead');
+    logger$7.warn('WebRTCPhone.getLocalMediaStream is deprecated, use WebRTCPhone.getLocalStream instead');
     return this.getLocalStream(callSession);
   }
 
@@ -8849,6 +9371,10 @@ class WebRTCPhone extends Emitter                  {
     return callSession ? this.client.hasLocalVideo(callSession.sipCallId) : null;
   }
 
+  hasALocalVideoTrack(callSession             ) {
+    return callSession ? this.client.hasALocalVideoTrack(callSession.sipCallId) : null;
+  }
+
   getRemoteStream(callSession             )               {
     return callSession ? this.client.getRemoteStream(callSession.sipCallId) : null;
   }
@@ -8871,7 +9397,7 @@ class WebRTCPhone extends Emitter                  {
     this.client.on(this.client.INVITE, (sipSession         , wantsToDoVideo         ) => {
       const autoAnswer = sipSession.request.getHeader('Answer-Mode') === 'Auto';
       const withVideo = this.allowVideo ? wantsToDoVideo : false;
-      logger$6.info('WebRTC invite received', { sipId: sipSession.id, withVideo, autoAnswer });
+      logger$7.info('WebRTC invite received', { sipId: sipSession.id, withVideo, autoAnswer });
 
       const callSession = this._createIncomingCallSession(sipSession, withVideo, null, autoAnswer);
       this.incomingSessions.push(callSession.getId());
@@ -8894,7 +9420,7 @@ class WebRTCPhone extends Emitter                  {
     });
 
     this.client.on(this.client.ON_REINVITE, (...args) => {
-      logger$6.info('WebRTC on reinvite', {
+      logger$7.info('WebRTC on reinvite', {
         sessionId: args[0].id,
         inviteId: args[1].id,
         updatedCalleeName: args[2],
@@ -8914,7 +9440,7 @@ class WebRTCPhone extends Emitter                  {
     });
 
     this.client.on(this.client.ACCEPTED, (sipSession         ) => {
-      logger$6.info('WebRTC call accepted', { sipId: sipSession.id });
+      logger$7.info('WebRTC call accepted', { sipId: sipSession.id });
 
       this._onCallAccepted(sipSession, this.client.hasVideo(this.getSipSessionId(sipSession)));
 
@@ -8925,17 +9451,17 @@ class WebRTCPhone extends Emitter                  {
     this.client.on('ended', () => {});
 
     this.client.on(this.client.ON_ERROR, e => {
-      logger$6.error('WebRTC error', e);
+      logger$7.error('WebRTC error', e);
       this.eventEmitter.emit(ON_CALL_ERROR, e);
     });
 
     this.client.on(this.client.UNREGISTERED, () => {
-      logger$6.info('WebRTC unregistered');
+      logger$7.info('WebRTC unregistered');
       this.eventEmitter.emit(ON_UNREGISTERED);
     });
 
     this.client.on(this.client.REGISTERED, () => {
-      logger$6.info('WebRTC registered', {
+      logger$7.info('WebRTC registered', {
         shouldSendReinvite: this.shouldSendReinvite,
         state: this.currentSipSession ? this.currentSipSession.state : null,
         currentSipSession: !!this.currentSipSession,
@@ -8951,19 +9477,19 @@ class WebRTCPhone extends Emitter                  {
         try {
           this.sendReinvite(this.currentCallSession);
         } catch (e) {
-          logger$6.error('WebRTC reinvite after register, error', { message: e.message, stack: e.stack });
+          logger$7.error('WebRTC reinvite after register, error', { message: e.message, stack: e.stack });
         }
       }
     });
 
     this.client.on(this.client.CONNECTED, () => {
-      logger$6.info('WebRTC client connected');
+      logger$7.info('WebRTC client connected');
 
       this.stopHeartbeat();
     });
 
     this.client.on(this.client.DISCONNECTED, () => {
-      logger$6.info('WebRTC client disconnected');
+      logger$7.info('WebRTC client disconnected');
 
       this.eventEmitter.emit(ON_UNREGISTERED);
 
@@ -9195,7 +9721,7 @@ var PHONE_EVENTS = /*#__PURE__*/Object.freeze({
 
 //      
 
-const logger$5 = IssueReporter$1.loggerFor('simple-phone');
+const logger$6 = IssueReporter$1.loggerFor('simple-phone');
 const sipLogger = IssueReporter$1.loggerFor('sip.js');
 const protocolLogger = IssueReporter$1.loggerFor('sip');
 
@@ -9302,7 +9828,7 @@ class Phone extends Emitter {
   async disconnect() {
     if (this.phone) {
       if (this.phone.hasAnActiveCall()) {
-        logger$5.info('hangup call on disconnect');
+        logger$6.info('hangup call on disconnect');
         // $FlowFixMe
         await this.phone.hangup();
       }
@@ -9325,13 +9851,13 @@ class Phone extends Emitter {
   }
 
   async hangup(callSession             ) {
-    logger$5.info('hangup via simple phone', { callId: callSession.getId() });
+    logger$6.info('hangup via simple phone', { callId: callSession.getId() });
 
     return this.phone && this.phone.hangup(callSession);
   }
 
   async accept(callSession             , cameraEnabled          ) {
-    logger$5.info('accept via simple phone', { callId: callSession.getId(), cameraEnabled });
+    logger$6.info('accept via simple phone', { callId: callSession.getId(), cameraEnabled });
 
     return this.phone && this.phone.accept(callSession, cameraEnabled);
   }
@@ -9351,13 +9877,18 @@ class Phone extends Emitter {
     return adHocConference.start();
   }
 
-  mute(callSession             ) {
-    this.muteViaAPI(callSession);
+  mute(callSession             , withApi          = true) {
+    if (withApi) {
+      this.muteViaAPI(callSession);
+    }
+
     return this.phone && this.phone.mute(callSession);
   }
 
-  unmute(callSession             ) {
-    this.unmuteViaAPI(callSession);
+  unmute(callSession             , withApi          = true) {
+    if (withApi) {
+      this.unmuteViaAPI(callSession);
+    }
 
     return this.phone && this.phone.unmute(callSession);
   }
@@ -9365,7 +9896,7 @@ class Phone extends Emitter {
   muteViaAPI(callSession             ) {
     if (callSession && callSession.callId) {
       Wazo.getApiClient().calld.mute(callSession.callId).catch(e => {
-        logger$5.error('Mute via API, error', e);
+        logger$6.error('Mute via API, error', e);
       });
     }
   }
@@ -9373,7 +9904,7 @@ class Phone extends Emitter {
   unmuteViaAPI(callSession             ) {
     if (callSession && callSession.callId) {
       Wazo.getApiClient().calld.unmute(callSession.callId).catch(e => {
-        logger$5.error('Unmute via API, error', e);
+        logger$6.error('Unmute via API, error', e);
       });
     }
   }
@@ -9463,9 +9994,13 @@ class Phone extends Emitter {
     return this.phone && this.phone.hasLocalVideo(callSession);
   }
 
+  hasALocalVideoTrack(callSession             ) {
+    return this.phone && this.phone.hasALocalVideoTrack(callSession);
+  }
+
   // @Deprecated
   getLocalMediaStream(callSession             ) {
-    logger$5.warn('Phone.getLocalMediaStream is deprecated, use Phone.getLocalStream instead');
+    logger$6.warn('Phone.getLocalMediaStream is deprecated, use Phone.getLocalStream instead');
 
     return this.phone && this.phone.getLocalStream(callSession);
   }
@@ -9484,20 +10019,20 @@ class Phone extends Emitter {
 
   // @Deprecated
   getRemoteStreamForCall(callSession             ) {
-    logger$5.warn('Phone.getRemoteStreamForCall is deprecated, use Phone.getRemoteStream instead');
+    logger$6.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.getRemoteStreamsForCall is deprecated, use Phone.getLocalStream instead');
+    logger$6.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');
+    logger$6.warn('Phone.getRemoteVideoStreamForCall is deprecated, use Phone.getRemoteVideoStream instead');
 
     return this.getRemoteVideoStream(callSession);
   }
@@ -9627,6 +10162,8 @@ const CONFERENCE_USER_PARTICIPANT_JOINED = 'conference_user_participant_joined';
 const CONFERENCE_USER_PARTICIPANT_LEFT = 'conference_user_participant_left';
 const CONFERENCE_USER_PARTICIPANT_TALK_STARTED = 'conference_user_participant_talk_started';
 const CONFERENCE_USER_PARTICIPANT_TALK_STOPPED = 'conference_user_participant_talk_stopped';
+const MEETING_USER_PARTICIPANT_JOINED = 'meeting_user_participant_joined';
+const MEETING_USER_PARTICIPANT_LEFT = 'meeting_user_participant_left';
 const SWITCHBOARD_QUEUED_CALLS_UPDATED = 'switchboard_queued_calls_updated';
 const SWITCHBOARD_QUEUED_CALL_ANSWERED = 'switchboard_queued_call_answered';
 const SWITCHBOARD_HELD_CALLS_UPDATED = 'switchboard_held_calls_updated';
@@ -9668,7 +10205,7 @@ const BLACKLIST_EVENTS = [
 ];
 
 const HEARTBEAT_ENGINE_VERSION = '20.09';
-const logger$4 = IssueReporter$1.loggerFor('wazo-ws');
+const logger$5 = IssueReporter$1.loggerFor('wazo-ws');
 const messageLogger = IssueReporter$1.loggerFor('wazo-ws-message');
 
 class WebSocketClient extends Emitter {
@@ -9717,19 +10254,19 @@ class WebSocketClient extends Emitter {
   }
 
   connect() {
-    logger$4.info('connect method started', { host: this.host, token: this.token });
+    logger$5.info('connect method started', { host: this.host, token: this.token });
     this.socket = new ReconnectingWebSocket(this._getUrl.bind(this), [], this.options);
     if (this.options.binaryType) {
       this.socket.binaryType = this.options.binaryType;
     }
 
     this.socket.onopen = () => {
-      logger$4.info('on Wazo WS open', { method: 'connect', host: this.host });
+      logger$5.info('on Wazo WS open', { method: 'connect', host: this.host });
       this.eventEmitter.emit(SOCKET_EVENTS$1.ON_OPEN);
     };
 
     this.socket.onerror = event => {
-      logger$4.error('on Wazo WS error', event.target);
+      logger$5.error('on Wazo WS error', event.target);
       this.eventEmitter.emit(SOCKET_EVENTS$1.ON_ERROR, event);
     };
 
@@ -9759,7 +10296,7 @@ class WebSocketClient extends Emitter {
 
     this.socket.onclose = event => {
       // Can't be converted to JSON (circular structure)
-      logger$4.info('on Wazo WS close', {
+      logger$5.info('on Wazo WS close', {
         reason: event.reason,
         code: event.code,
         readyState: event.target.readyState,
@@ -9777,12 +10314,12 @@ class WebSocketClient extends Emitter {
     };
 
     this.socket.onerror = event => {
-      logger$4.info('Wazo WS error', { message: event.message, code: event.code, readyState: event.target.readyState });
+      logger$5.info('Wazo WS error', { message: event.message, code: event.code, readyState: event.target.readyState });
     };
   }
 
   close(force          = false)       {
-    logger$4.info('Wazo WS close', { socket: !!this.socket, host: this.host, token: this.token });
+    logger$5.info('Wazo WS close', { socket: !!this.socket, host: this.host, token: this.token });
 
     if (!this.socket) {
       return;
@@ -9800,7 +10337,7 @@ class WebSocketClient extends Emitter {
 
   updateToken(token        ) {
     this.token = token;
-    logger$4.info('Wazo WS updating token', { url: this._getUrl(), token, socket: !!this.socket });
+    logger$5.info('Wazo WS updating token', { url: this._getUrl(), token, socket: !!this.socket });
 
     if (this.socket) {
       // If still connected, send the token to the WS
@@ -9818,7 +10355,7 @@ class WebSocketClient extends Emitter {
   }
 
   startHeartbeat() {
-    logger$4.info('Wazo WS start heartbeat', { host: this.host, token: this.token });
+    logger$5.info('Wazo WS start heartbeat', { host: this.host, token: this.token });
 
     if (!this.socket) {
       this.heartbeat.stop();
@@ -9832,7 +10369,7 @@ class WebSocketClient extends Emitter {
   }
 
   stopHeartbeat() {
-    logger$4.info('Wazo WS stop heartbeat', { host: this.host, token: this.token });
+    logger$5.info('Wazo WS stop heartbeat', { host: this.host, token: this.token });
 
     this.heartbeat.stop();
   }
@@ -9862,7 +10399,7 @@ class WebSocketClient extends Emitter {
   }
 
   reconnect(reason        ) {
-    logger$4.info('Wazo WS reconnect', { reason, socket: !!this.socket, host: this.host, token: this.token });
+    logger$5.info('Wazo WS reconnect', { reason, socket: !!this.socket, host: this.host, token: this.token });
     if (!this.socket) {
       return;
     }
@@ -9918,7 +10455,7 @@ class WebSocketClient extends Emitter {
       this.close();
     }
     const url = `wss://${this.host || ''}/api/websocketd/?token=${this.token || ''}&version=${this.version}`;
-    logger$4.log('Wazo WS url computed to reconnect', { url });
+    logger$5.log('Wazo WS url computed to reconnect', { url });
 
     return url;
   }
@@ -9926,12 +10463,12 @@ class WebSocketClient extends Emitter {
   _onHeartbeat(message        ) {
     if (message.payload === 'pong') {
       this.heartbeat.onHeartbeat();
-      logger$4.log('on heartbeat received from Wazo WS');
+      logger$5.log('on heartbeat received from Wazo WS');
     }
   }
 
   async _onHeartbeatTimeout() {
-    logger$4.log('heartbeat timed out', { host: this.host, token: this.token });
+    logger$5.log('heartbeat timed out', { host: this.host, token: this.token });
 
     this.close();
     this.eventEmitter.emit(SOCKET_EVENTS$1.ON_CLOSE, new Error('Websocket ping failure.'));
@@ -9973,6 +10510,8 @@ WebSocketClient.eventLists = [
   CHATD_USER_ROOM_CREATED,
   CONFERENCE_USER_PARTICIPANT_JOINED,
   CONFERENCE_USER_PARTICIPANT_LEFT,
+  MEETING_USER_PARTICIPANT_JOINED,
+  MEETING_USER_PARTICIPANT_LEFT,
   CONFERENCE_USER_PARTICIPANT_TALK_STARTED,
   CONFERENCE_USER_PARTICIPANT_TALK_STOPPED,
   SWITCHBOARD_QUEUED_CALLS_UPDATED,
@@ -10043,6 +10582,8 @@ var WebSocketClient$1 = /*#__PURE__*/Object.freeze({
   CONFERENCE_USER_PARTICIPANT_LEFT: CONFERENCE_USER_PARTICIPANT_LEFT,
   CONFERENCE_USER_PARTICIPANT_TALK_STARTED: CONFERENCE_USER_PARTICIPANT_TALK_STARTED,
   CONFERENCE_USER_PARTICIPANT_TALK_STOPPED: CONFERENCE_USER_PARTICIPANT_TALK_STOPPED,
+  MEETING_USER_PARTICIPANT_JOINED: MEETING_USER_PARTICIPANT_JOINED,
+  MEETING_USER_PARTICIPANT_LEFT: MEETING_USER_PARTICIPANT_LEFT,
   SWITCHBOARD_QUEUED_CALLS_UPDATED: SWITCHBOARD_QUEUED_CALLS_UPDATED,
   SWITCHBOARD_QUEUED_CALL_ANSWERED: SWITCHBOARD_QUEUED_CALL_ANSWERED,
   SWITCHBOARD_HELD_CALLS_UPDATED: SWITCHBOARD_HELD_CALLS_UPDATED,
@@ -10084,7 +10625,7 @@ var WebSocketClient$1 = /*#__PURE__*/Object.freeze({
 const { SOCKET_EVENTS, ...OTHER_EVENTS } = WebSocketClient$1;
 const ALL_EVENTS = [...Object.values(SOCKET_EVENTS), ...Object.values(OTHER_EVENTS)];
 
-const logger$3 = IssueReporter$1.loggerFor('simple-ws-client');
+const logger$4 = IssueReporter$1.loggerFor('simple-ws-client');
 
 class Websocket extends Emitter {
                            
@@ -10108,7 +10649,7 @@ class Websocket extends Emitter {
   }
 
   open(host        , session         ) {
-    logger$3.info('open simple WebSocket', { host, token: session.token });
+    logger$4.info('open simple WebSocket', { host, token: session.token });
     this.ws = new WebSocketClient(
       {
         host,
@@ -10136,7 +10677,7 @@ class Websocket extends Emitter {
   }
 
   updateToken(token        ) {
-    logger$3.info('update token via simple Websocket', { token, ws: !!this.ws });
+    logger$4.info('update token via simple Websocket', { token, ws: !!this.ws });
 
     if (!this.ws) {
       return;
@@ -10164,7 +10705,7 @@ var Websocket$1 = global.wazoWebsocketInstance;
 
 //      
 
-const logger$2 = IssueReporter$1.loggerFor('room');
+const logger$3 = IssueReporter$1.loggerFor('room');
 
 class Participant extends Emitter {
              
@@ -10198,6 +10739,7 @@ class Participant extends Emitter {
                     
 
   /**
+   * @param room Room The room where the participant is
    * @param rawParticipant string Participant sent via the Wazo WS
    * @param extra Object extra status of the participant
    */
@@ -10285,7 +10827,7 @@ class Participant extends Emitter {
   }
 
   onTalking(isTalking         ) {
-    logger$2.info('on participant talking', { name: this.name, isTalking, callId: this.callId });
+    logger$3.info('on participant talking', { name: this.name, isTalking, callId: this.callId });
     this.isTalking = isTalking;
     // you may notice we're not broadcasting: since all participants are getting this info
     // directly from asterisk, there's no need to do so
@@ -10388,7 +10930,7 @@ class Participant extends Emitter {
   }
 
   updateStatus(status        , broadcast          = true) {
-    logger$2.info('updating participant status', { name: this.name, status });
+    logger$3.info('updating participant status', { name: this.name, status });
 
     if (typeof status.audioMuted !== 'undefined' && status.audioMuted !== this.audioMuted) {
       if (status.audioMuted) {
@@ -10425,13 +10967,18 @@ class Participant extends Emitter {
     // Poor man's object comparison
     if (typeof status.extra !== 'undefined' && JSON.stringify(this.extra) !== JSON.stringify(status.extra)) {
       this.extra = { ...this.extra, ...status.extra };
+
+      if (this.extra.contact && !(this.extra.contact instanceof Contact)) {
+        this.extra.contact = new Contact(this.extra.contact);
+      }
+
       this.triggerUpdate(this.ON_EXTRA_CHANGE, broadcast);
     }
   }
 
   broadcastStatus(inboundStatus         = null) {
     const status = inboundStatus || this.getStatus();
-    logger$2.info('broadcasting participant status', { callId: this.callId, status });
+    logger$3.info('broadcasting participant status', { callId: this.callId, status });
 
     this.room.sendSignal({
       type: SIGNAL_TYPE_PARTICIPANT_UPDATE,
@@ -10452,18 +10999,24 @@ class RemoteParticipant extends Participant {
   }
 }
 
-/* global document */
+//      
+
+class LocalParticipant extends Participant {
+}
+
+//      
 
 const SIGNAL_TYPE_PARTICIPANT_UPDATE = 'signal/PARTICIPANT_UPDATE';
 const SIGNAL_TYPE_PARTICIPANT_REQUEST = 'signal/PARTICIPANT_REQUEST';
 
-const logger$1 = IssueReporter$1.loggerFor('sdk-room');
+const logger$2 = IssueReporter$1.loggerFor('sdk-room');
 
 class Room$1 extends Emitter {
                             
                
                     
                     
+                       
                               
                   
                      
@@ -10485,6 +11038,8 @@ class Room$1 extends Emitter {
 
                                              
                                            
+                                          
+                                        
                                 
                      
                   
@@ -10502,6 +11057,7 @@ class Room$1 extends Emitter {
    * @param extension string
    * @param sourceId number
    * @param callId string
+   * @param meetingUuid string
    * @param extra Object
    */
   constructor(
@@ -10509,15 +11065,17 @@ class Room$1 extends Emitter {
     extension        ,
     sourceId         ,
     callId         ,
+    meetingUuid         ,
     extra         = {},
   ) {
     super();
-    logger$1.info('room initialized', { callId, extension, sourceId });
+    logger$2.info('room initialized', { callId, extension, sourceId, meetingUuid });
 
     // Represents the room callSession
     this.callSession = callSession;
     this.extension = extension;
     this.sourceId = sourceId;
+    this.meetingUuid = meetingUuid;
     this.callId = callId;
     this.participants = [];
     this.connected = false;
@@ -10537,6 +11095,8 @@ class Room$1 extends Emitter {
     // Sugar syntax for `room.EVENT_NAME`
     this.CONFERENCE_USER_PARTICIPANT_JOINED = Wazo.Websocket.CONFERENCE_USER_PARTICIPANT_JOINED;
     this.CONFERENCE_USER_PARTICIPANT_LEFT = Wazo.Websocket.CONFERENCE_USER_PARTICIPANT_LEFT;
+    this.MEETING_USER_PARTICIPANT_JOINED = Wazo.Websocket.MEETING_USER_PARTICIPANT_JOINED;
+    this.MEETING_USER_PARTICIPANT_LEFT = Wazo.Websocket.MEETING_USER_PARTICIPANT_LEFT;
     this.ON_SHARE_SCREEN_ENDED = Wazo.Phone.ON_SHARE_SCREEN_ENDED;
     this.ON_MESSAGE = Wazo.Phone.ON_MESSAGE;
     this.ON_CHAT = Wazo.Phone.ON_CHAT;
@@ -10571,10 +11131,11 @@ class Room$1 extends Emitter {
    * @param audioOnly boolean
    * @param extra Object
    * @param room ?Room
+   * @param meeting ?Meeting
    * @returns {Promise<Room>}
    */
-  static async connect({ extension, constraints, audioOnly = false, extra, room }        ) {
-    logger$1.info('connecting to room', { extension, audioOnly, room: !!room });
+  static async connect({ extension, constraints, audioOnly = false, extra, room, meeting }        ) {
+    logger$2.info('connecting to room', { extension, audioOnly, room: !!room });
 
     if (!room) {
       await Wazo.Phone.connect();
@@ -10587,7 +11148,7 @@ class Room$1 extends Emitter {
 
       // Call_created is triggered before call_accepted, so we have to listen for it here.
       Wazo.Websocket.once(Wazo.Websocket.CALL_CREATED, ({ data }) => {
-        logger$1.info('room call received via WS', { callId: data.call_id });
+        logger$2.info('room call received via WS', { callId: data.call_id });
         if (room) {
           room.setCallId(data.call_id);
         }
@@ -10608,34 +11169,44 @@ class Room$1 extends Emitter {
       room.setCallId(room.callSession.call.id);
     }
 
-    // Fetch conference source
-    const sources = await getApiClient().dird.fetchConferenceSource('default');
-    // Retrieve conference sources
-    const contacts = await getApiClient().dird.fetchConferenceContacts(sources.items[0]);
-    // Retrieve conference
-    const conference = contacts.find(contact => contact.numbers.find(number => number.number === extension));
+    if (!meeting) {
+      // Fetch conference source
+      const sources = await getApiClient().dird.fetchConferenceSource('default');
+      // Retrieve conference sources
+      const contacts = await getApiClient().dird.fetchConferenceContacts(sources.items[0]);
+      // Retrieve conference
+      const conference = contacts.find(contact => contact.numbers.find(number => number.number === extension));
 
-    logger$1.info('connected to room', {
-      sourceId: conference ? conference.sourceId : null,
-      name: conference ? conference.name : null,
-    });
+      logger$2.info('connected to room', {
+        sourceId: conference ? conference.sourceId : null,
+        name: conference ? conference.name : null,
+      });
 
-    if (conference) {
-      room.setSourceId(conference.sourceId);
-      room.setName(conference.name);
+      if (conference) {
+        room.setSourceId(conference.sourceId);
+        room.setName(conference.name);
+      }
+    } else if (meeting) {
+      logger$2.info('Already connected to meeting', {
+        uuid: meeting.uuid,
+        name: meeting.name,
+      });
+
+      room.setMeetingUuid(meeting.uuid);
+      room.setName(meeting.name);
     }
 
     return room;
   }
 
   static disconnect() {
-    logger$1.info('static disconnection to room');
+    logger$2.info('static disconnection to room');
 
     Wazo.Phone.disconnect();
   }
 
   async disconnect() {
-    logger$1.info('disconnection to room called');
+    logger$2.info('disconnection to room called');
 
     await Wazo.Phone.hangup(this.callSession);
     this.callSession = null;
@@ -10650,20 +11221,24 @@ class Room$1 extends Emitter {
     Wazo.Phone.phone.off(Wazo.Phone.phone.client.ON_REINVITE, this._boundOnReinvite);
     Wazo.Websocket.off(this.CONFERENCE_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
     Wazo.Websocket.off(this.CONFERENCE_USER_PARTICIPANT_LEFT, this._boundOnParticipantLeft);
-
-    if (this.roomAudioElement && document.body) {
-      document.body.removeChild(this.roomAudioElement);
-    }
+    Wazo.Websocket.off(this.MEETING_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
+    Wazo.Websocket.off(this.MEETING_USER_PARTICIPANT_LEFT, this._boundOnParticipantLeft);
   }
 
   setSourceId(sourceId        ) {
-    logger$1.info('set room source id', { sourceId });
+    logger$2.info('set room source id', { sourceId });
 
     this.sourceId = sourceId;
   }
 
+  setMeetingUuid(meetingUuid        ) {
+    logger$2.info('set meeting uuid', { meetingUuid });
+
+    this.meetingUuid = meetingUuid;
+  }
+
   setCallId(callId        ) {
-    logger$1.info('set room call id', { callId });
+    logger$2.info('set room call id', { callId });
 
     if (callId) {
       this.callId = callId;
@@ -10671,7 +11246,7 @@ class Room$1 extends Emitter {
   }
 
   setName(name        ) {
-    logger$1.info('set room name', { name });
+    logger$2.info('set room name', { name });
 
     this.name = name;
   }
@@ -10690,7 +11265,7 @@ class Room$1 extends Emitter {
   }
 
   async startScreenSharing(constraints        ) {
-    logger$1.info('start room screen sharing', { constraints });
+    logger$2.info('start room screen sharing', { constraints });
 
     const screensharingStream = await Wazo.Phone.startScreenSharing(constraints, this.callSession);
     if (!screensharingStream) {
@@ -10703,18 +11278,26 @@ class Room$1 extends Emitter {
     return screensharingStream;
   }
 
-  stopScreenSharing(restoreLocalStream          = true) {
-    logger$1.info('stop room screen sharing');
+  async stopScreenSharing(restoreLocalStream          = true) {
+    logger$2.info('stop room screen sharing');
 
-    Wazo.Phone.stopScreenSharing(this.callSession, restoreLocalStream);
+    const reinvited = await Wazo.Phone.stopScreenSharing(this.callSession, restoreLocalStream);
 
     if (this.localParticipant) {
       this.localParticipant.onStopScreensharing();
     }
+
+    if (!reinvited && this.localParticipant) {
+      // When we had video and we made a screenshare we don't reinvite when stopping the screensahre
+      // So not REINVITE even is fired, we have to restore the video stream manually
+      const localVideoStream = Wazo.Phone.getLocalVideoStream(this.callSession);
+      // $FlowFixMe
+      this._associateStreamTo(localVideoStream, this.localParticipant);
+    }
   }
 
   turnCameraOff() {
-    logger$1.info('turn room camera off');
+    logger$2.info('turn room camera off');
 
     Wazo.Phone.turnCameraOff(this.callSession);
 
@@ -10724,7 +11307,7 @@ class Room$1 extends Emitter {
   }
 
   turnCameraOn() {
-    logger$1.info('turn room camera on');
+    logger$2.info('turn room camera on');
 
     Wazo.Phone.turnCameraOn(this.callSession);
 
@@ -10734,7 +11317,7 @@ class Room$1 extends Emitter {
   }
 
   mute() {
-    logger$1.info('mute room');
+    logger$2.info('mute room');
 
     Wazo.Phone.mute(this.callSession);
 
@@ -10742,7 +11325,7 @@ class Room$1 extends Emitter {
   }
 
   unmute() {
-    logger$1.info('unmute room');
+    logger$2.info('unmute room');
 
     Wazo.Phone.unmute(this.callSession);
 
@@ -10762,7 +11345,7 @@ class Room$1 extends Emitter {
   }
 
   hold() {
-    logger$1.info('hold room');
+    logger$2.info('hold room');
 
     Wazo.Phone.hold(this.callSession, true);
 
@@ -10772,7 +11355,7 @@ class Room$1 extends Emitter {
   }
 
   resume() {
-    logger$1.info('resume room');
+    logger$2.info('resume room');
 
     Wazo.Phone.resume(this.callSession, true);
 
@@ -10782,13 +11365,13 @@ class Room$1 extends Emitter {
   }
 
   sendDTMF(tone        ) {
-    logger$1.info('send room DTMF', { tone });
+    logger$2.info('send room DTMF', { tone });
 
     Wazo.Phone.sendDTMF(tone, this.callSession);
   }
 
   async sendReinvite(newConstraints         = null) {
-    logger$1.info('send room reinvite', { callId: this.callSession ? this.callSession.getId() : null, newConstraints });
+    logger$2.info('send room reinvite', { callId: this.callSession ? this.callSession.getId() : null, newConstraints });
     const wasScreensharing = this.localParticipant && this.localParticipant.screensharing;
 
     Wazo.Phone.on(Wazo.Phone.ON_SHARE_SCREEN_STARTED, () => {
@@ -10813,6 +11396,22 @@ class Room$1 extends Emitter {
     return response;
   }
 
+  hasALocalVideoTrack() {
+    return Wazo.Phone.hasALocalVideoTrack(this.callSession);
+  }
+
+  getLocalStream() {
+    return Wazo.Phone.getLocalStream(this.callSession);
+  }
+
+  getRemoteStream() {
+    return Wazo.Phone.getRemoteStream(this.callSession);
+  }
+
+  getRemoteVideoStream() {
+    return Wazo.Phone.getRemoteVideoStream(this.callSession);
+  }
+
   _bindEvents() {
     if (!Wazo.Phone.phone || !Wazo.Phone.phone.currentSipSession) {
       return;
@@ -10831,35 +11430,18 @@ class Room$1 extends Emitter {
     Wazo.Phone.phone.on(Wazo.Phone.phone.client.ON_REINVITE, this._boundOnReinvite);
 
     this.on(this.ON_AUDIO_STREAM, stream => {
-      logger$1.info('on room audio stream');
+      logger$2.info('on room audio stream');
 
       this.audioStream = stream;
-      if (document.createElement) {
-        // $FlowFixMe
-        let roomAudioElement                   = document.getElementById('audio-room');
-        if (!this.roomAudioElement) {
-          roomAudioElement = document.createElement('audio');
-          // $FlowFixMe
-          document.body.appendChild(roomAudioElement);
-        }
-        if (!roomAudioElement) {
-          return;
-        }
-        this.roomAudioElement = roomAudioElement;
+      if (!this.roomAudioElement) {
+        const sessionId = Wazo.Phone.phone.getSipSessionId(Wazo.Phone.phone.currentSipSession);
+        this.roomAudioElement = Wazo.Phone.phone.createAudioElementFor(sessionId);
         this.roomAudioElement.srcObject = stream;
-        this.roomAudioElement.autoplay = true;
-        this.roomAudioElement.id = 'audio-room';
-
-        // $FlowFixMe
-        if (this.roomAudioElement.setSinkId) {
-          // $FlowFixMe
-          this.roomAudioElement.setSinkId(Wazo.Phone.getOutputDevice());
-        }
       }
     });
 
     this.on(this.ON_VIDEO_STREAM, (stream, streamId, event, sipSession) => {
-      logger$1.info('on room video stream', { streamId });
+      logger$2.info('on room video stream', { streamId });
 
       this._mapMsid(sipSession.body.body);
 
@@ -10874,7 +11456,7 @@ class Room$1 extends Emitter {
     });
 
     this.on(this.ON_REMOVE_STREAM, stream => {
-      logger$1.info('on room remove stream');
+      logger$2.info('on room remove stream');
 
       const participant = this.participants.find(someParticipant =>
         someParticipant.streams.find(someStream => someStream && someStream.id === stream.id));
@@ -10929,6 +11511,9 @@ class Room$1 extends Emitter {
     Wazo.Websocket.on(this.CONFERENCE_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
     Wazo.Websocket.on(this.CONFERENCE_USER_PARTICIPANT_LEFT, this._boundOnParticipantLeft);
 
+    Wazo.Websocket.on(this.MEETING_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
+    Wazo.Websocket.on(this.MEETING_USER_PARTICIPANT_LEFT, this._boundOnParticipantLeft);
+
     // Phone events
     Wazo.Phone.on(this.ON_MESSAGE, this._boundOnMessage);
     Wazo.Phone.on(this.ON_CHAT, this._boundOnChat);
@@ -10939,15 +11524,15 @@ class Room$1 extends Emitter {
       Wazo.Phone.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter, [event, ...args])));
   }
 
-  _onMessage(message         ) {
+  _onMessage(message         )          {
     if (message.method !== 'MESSAGE') {
-      return;
+      return null;
     }
     let body;
     try {
       body = JSON.parse(message.body);
     } catch (e) {
-      return;
+      return null;
     }
 
     switch (body.type) {
@@ -10966,6 +11551,8 @@ class Room$1 extends Emitter {
     }
 
     this.eventEmitter.emit(this.ON_MESSAGE, body);
+
+    return body;
   }
 
   _onChat(content        ) {
@@ -11001,7 +11588,7 @@ class Room$1 extends Emitter {
         const requester               = this._getParticipantFromCallId(origin.callId);
         if (requester) {
           // @FIXME?: when need to trigger an update on join-in; this is a bit of a hack
-          logger$1.info('trigger room requester status', { origin });
+          logger$2.info('trigger room requester status', { origin });
           requester.triggerUpdate('REQUESTER_UPDATE');
         }
         break;
@@ -11030,25 +11617,26 @@ class Room$1 extends Emitter {
     const session = Wazo.Auth.getSession();
     let participants = [];
 
-    // @TODO: we could use a better function name here
-    const isJoining = part => {
-      this.__associateStreams(part);
-      // @VALIDATE: no need to publicize ourselves, no?
-      if (part instanceof RemoteParticipant) {
-        this.eventEmitter.emit(this.CONFERENCE_USER_PARTICIPANT_JOINED, part);
-      }
-    };
-
     // When we join the room, we can call `getConferenceParticipantsAsUser`, not before.
     if (participant.user_uuid === session.uuid) {
-      logger$1.info('room current user joined');
+      logger$2.info('room current user joined');
 
       // Retrieve participants via an API calls
       const conferenceId = this.sourceId || payload.data.conference_id;
-      const response = await getApiClient().calld.getConferenceParticipantsAsUser(conferenceId);
-      logger$1.info('fetching conference participants', { conferenceId });
+      let response;
+      try {
+        if (this.meetingUuid) {
+          logger$2.info('fetching meeting participants', { meetingUuid: this.meetingUuid });
+          response = await getApiClient().calld.getMeetingParticipantsAsUser(this.meetingUuid);
+        } else {
+          logger$2.info('fetching conference participants', { conferenceId });
+          response = await getApiClient().calld.getConferenceParticipantsAsUser(conferenceId);
+        }
+      } catch (e) {
+        logger$2.error('room participants fetching, error', e);
+      }
       if (response) {
-        logger$1.info('conference participants fetched', { nb: response.items.length });
+        logger$2.info('conference participants fetched', { nb: response.items.length });
         participants = response.items.map(item => {
           const isMe = item.call_id === this.callId;
 
@@ -11061,25 +11649,10 @@ class Room$1 extends Emitter {
 
         const localParticipant = participants.find(someParticipant => someParticipant instanceof Wazo.LocalParticipant);
         if (!this.localParticipant && localParticipant) {
-          this.localParticipant = localParticipant;
-
-          const localVideoStream = this._getLocalVideoStream();
-          if (localVideoStream) {
-            this._saveLocalVideoStream(localVideoStream);
-          }
-
-          this.connected = true;
-
-          // we're in the room, now let's request everyone's status
-          if (this.localParticipant) {
-            this.sendSignal({
-              type: SIGNAL_TYPE_PARTICIPANT_REQUEST,
-              origin: this.localParticipant.getStatus(),
-            });
-          }
+          this._onLocalParticipantJoined(localParticipant);
         }
 
-        participants.forEach(someParticipant => isJoining(someParticipant));
+        participants.forEach(someParticipant => this._isParticipantJoining(someParticipant));
         this.eventEmitter.emit(this.ON_JOINED, localParticipant, participants);
       }
 
@@ -11090,16 +11663,45 @@ class Room$1 extends Emitter {
       ? new Wazo.RemoteParticipant(this, participant)
       : null;
 
-    logger$1.info('other room user joined', { callId: participant.call_id, remoteParticipant: !!remoteParticipant });
+    logger$2.info('other room user joined', { callId: participant.call_id, remoteParticipant: !!remoteParticipant });
 
     if (remoteParticipant) {
       this.participants.push(remoteParticipant);
-      isJoining(remoteParticipant);
+      this._isParticipantJoining(remoteParticipant);
     }
 
     return remoteParticipant;
   }
 
+  _onLocalParticipantJoined(localParticipant                  ) {
+    this.localParticipant = localParticipant;
+
+    const localVideoStream = this._getLocalVideoStream();
+    if (localVideoStream) {
+      this._saveLocalVideoStream(localVideoStream);
+    }
+
+    this.connected = true;
+
+    localParticipant.broadcastStatus();
+
+    // we're in the room, now let's request everyone's status
+    if (this.localParticipant) {
+      this.sendSignal({
+        type: SIGNAL_TYPE_PARTICIPANT_REQUEST,
+        origin: this.localParticipant.getStatus(),
+      });
+    }
+  }
+
+  _isParticipantJoining(participant             ) {
+    this.__associateStreams(participant);
+    // @VALIDATE: no need to publicize ourselves, no?
+    if (participant instanceof RemoteParticipant) {
+      this.eventEmitter.emit(this.CONFERENCE_USER_PARTICIPANT_JOINED, participant);
+    }
+  }
+
   _saveLocalVideoStream(stream             ) {
     const { localParticipant } = this;
 
@@ -11145,9 +11747,11 @@ class Room$1 extends Emitter {
   _onParticipantTrackUpdate(oldParticipant             , update        )              {
     const newParticipant = oldParticipant;
 
-    const { trackId } = this._callIdStreamIdMap[newParticipant.callId] || {};
+    const { trackId, streamId } = this._callIdStreamIdMap[newParticipant.callId] || {};
     const pc = Wazo.Phone.phone.currentSipSession.sessionDescriptionHandler.peerConnection;
-    const stream = pc.getRemoteStreams().find(someStream => someStream.getTracks().some(track => track.id === trackId));
+    // Can't use `getReceivers` here because on FF we make the mapping based on the streamId
+    const stream = pc.getRemoteStreams().find(someStream =>
+      someStream.id === streamId || someStream.getTracks().some(track => track.id === trackId));
 
     if (update === 'downgrade') {
       newParticipant.streams = [];
@@ -11177,15 +11781,41 @@ class Room$1 extends Emitter {
       return;
     }
 
-    if (this._unassociatedVideoStreams[trackId]) {
+    const streamId = this._getStreamIdFrTrackId(trackId);
+    const key = this._getUnassociatedMapIdFromTrackIdOrStreamId(trackId, streamId);
+    const stream = this._unassociatedVideoStreams[key];
+
+    if (stream) {
       // Try to associate stream
-      this._associateStreamTo(this._unassociatedVideoStreams[trackId], participant);
+      this._associateStreamTo(stream, participant);
 
-      delete this._unassociatedVideoStreams[trackId];
+      delete this._unassociatedVideoStreams[key];
       delete this._unassociatedParticipants[participant.callId];
     }
   }
 
+  _getUnassociatedMapIdFromTrackIdOrStreamId(trackId        , streamId         ) {
+    // Find by trackId
+    if (trackId in this._unassociatedVideoStreams) {
+      return trackId;
+    }
+
+    // Find by streamId
+    if (streamId && streamId in this._unassociatedVideoStreams) {
+      return streamId;
+    }
+
+    // Find in all the streams by streamId (used on FF where we can't map by trackId)
+    const idx = Object.values(this._unassociatedVideoStreams).findIndex((stream        ) => stream.id === streamId);
+    return idx === -1 ? null : Object.keys(this._unassociatedVideoStreams)[idx];
+  }
+
+  _getStreamIdFrTrackId(trackId        ) {
+    const mapping         = Object.values(this._callIdStreamIdMap).find((map        ) => map.trackId === trackId);
+
+    return mapping ? mapping.streamId : null;
+  }
+
   _associateStreamTo(rawStream     , participant             ) {
     const stream = new Wazo.Stream(rawStream, participant);
     participant.streams.push(stream);
@@ -11209,7 +11839,141 @@ class Room$1 extends Emitter {
 
 //      
 
-class LocalParticipant extends Participant {
+const logger$1 = IssueReporter$1.loggerFor('sdk-sip-room');
+
+class SipRoom extends Room$1 {
+
+  static async connect({ extension, constraints, audioOnly = false, extra, room }        ) {
+    logger$1.info('connecting to sip room', { extension, audioOnly, room: !!room });
+
+    if (!room) {
+      await Wazo.Phone.connect();
+
+      const withCamera = constraints && !!constraints.video;
+
+      const callSession = await Wazo.Phone.call(extension, withCamera, null, audioOnly, true);
+      // eslint-disable-next-line no-param-reassign
+      room = new SipRoom(callSession, extension, null, null, extra);
+    }
+
+    if (room && room.callSession && room.callSession.call) {
+      room.setCallId(room.callSession.call.id);
+    }
+
+    logger$1.info('connected to room', {
+      extension: room.extension,
+    });
+
+    return room;
+  }
+
+  mute() {
+    logger$1.info('mute sip room');
+
+    Wazo.Phone.mute(this.callSession, false);
+
+    this.sendMuteStatus();
+  }
+
+  unmute() {
+    logger$1.info('unmute sip room');
+
+    Wazo.Phone.unmute(this.callSession, false);
+
+    this.sendUnMuteStatus();
+  }
+
+  getLocalGuestName() {
+    return Wazo.Phone.phone.client.userAgent.options.displayName;
+  }
+
+  // Overridden to not listen to websocket messages
+  _transferEvents() {
+    // Phone events
+    Wazo.Phone.on(this.ON_MESSAGE, this._boundOnMessage);
+    Wazo.Phone.on(this.ON_CHAT, this._boundOnChat);
+    Wazo.Phone.on(this.ON_SIGNAL, this._boundOnSignal);
+    Wazo.Phone.on(this.ON_VIDEO_INPUT_CHANGE, this._boundSaveLocalVideoStream);
+
+    [this.ON_AUDIO_STREAM, this.ON_VIDEO_STREAM, this.ON_REMOVE_STREAM].forEach(event =>
+      Wazo.Phone.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter, [event, ...args])));
+  }
+
+  _onMessage(message         ) {
+    // eslint-disable-next-line no-underscore-dangle
+    const body = super._onMessage(message);
+    if (!body) {
+      return;
+    }
+
+    const getChannel = () => body.channels[0];
+
+    switch (body.type) {
+      case 'ConfbridgeWelcome':
+        body.channels.forEach(channel => {
+          this._onParticipantJoined(channel);
+        });
+
+        break;
+      case 'ConfbridgeJoin': {
+        const channel = getChannel();
+        this._onParticipantJoined(channel);
+        break;
+      }
+      case 'ConfbridgeLeave': {
+        const channel = getChannel();
+        this._onParticipantLeft({
+          data: {
+            call_id: channel.id,
+          },
+        });
+        break;
+      }
+    }
+  }
+
+  async _onParticipantJoined(channel        ) {
+    const isLocal = channel.channelvars.WAZO_SIP_CALL_ID === this._getCurrentSipCallIs();
+    const callId = channel.id;
+    const ParticipantClass = isLocal ? Wazo.LocalParticipant : Wazo.RemoteParticipant;
+    const name = channel.caller ? channel.caller.name : null;
+    const extra = isLocal ? { guestName: this.getLocalGuestName() } : {};
+    const participant = new ParticipantClass(this, {
+      caller_id_name: name,
+      call_id: callId,
+    }, extra);
+
+    const participantIdx = this.participants.findIndex(other => other.callId === participant.callId);
+    if (participantIdx !== -1 && name) {
+      this.participants[participantIdx].name = name;
+      return;
+    }
+
+    if (isLocal) {
+      // Should be updated by the Wazo WS but we don't have it for now
+      if (this.callSession) {
+        this.callSession.ringing = false;
+      }
+
+      this._onLocalParticipantJoined(participant);
+
+      // Give some time for the stream to be updated
+      setTimeout(() => {
+        this.eventEmitter.emit(this.ON_JOINED, participant, this.participants);
+      }, 1000);
+    }
+
+    this.participants.push(participant);
+
+    this._isParticipantJoining(participant);
+
+    return participant;
+  }
+
+  _getCurrentSipCallIs() {
+    return Wazo.Phone.getSipSessionId(Wazo.Phone.phone.currentSipSession);
+  }
+
 }
 
 //      
@@ -12105,6 +12869,7 @@ const Wazo = {
   Phone: Phone$1,
   Websocket: Websocket$1,
   Room: Room$1,
+  SipRoom,
   RemoteParticipant,
   LocalParticipant,
   Stream,
@@ -12124,6 +12889,7 @@ const Wazo = {
     ServerError,
     Call,
     CallLog,
+    CTIPhone,
     Recording,
     ChatMessage,
     ChatRoom,
@@ -12139,6 +12905,8 @@ const Wazo = {
     CallSession,
     IndirectTransfer,
     SwitchboardCall,
+    WebRTCPhone,
+    Meeting,
   },
 
   // Api
@@ -12217,9 +12985,7 @@ class Stream {
       return false;
     }
 
-    // With canvas track (used to fake upgrade in conference), we don't have a width
-    return this.htmlStream.getTracks().find(track => track.kind === 'video'
-      && track.readyState !== 'ended' && 'width' in track.getSettings());
+    return this.htmlStream.getTracks().some(track => track.kind === 'video' && track.readyState !== 'ended');
   }
 
   get id() {