@wazo/sdk 0.37.20 → 0.37.24

package/lib/websocket-client.js

@@ -45,7 +45,7 @@ const isMobile = () => typeof navigator !== 'undefined' && navigator.product ===
 
 /*       */
 
-IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
+const logger = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
 
 // Use a function here to be able to mock it in tests
 const realFetch = () => {
@@ -131,6 +131,7 @@ class IssueReporter {
                             
                                 
                                   
+                       
 
   constructor() {
     addLevelsTo(this);
@@ -142,12 +143,17 @@ class IssueReporter {
     this.bufferTimeout = null;
     this._boundProcessBuffer = this._processBuffer.bind(this);
     this._boundParseLoggerBody = this._parseLoggerBody.bind(this);
+    this._callback = null;
   }
 
   init() {
     this._catchConsole();
   }
 
+  setCallback(cb          ) {
+    this._callback = cb;
+  }
+
   configureRemoteClient(configuration         = { tag: 'wazo-sdk', host: null, port: null, level: null, extra: {} }) {
     this.remoteClientConfiguration = configuration;
   }
@@ -183,6 +189,7 @@ class IssueReporter {
 
     // Handle category label
     let category = null;
+    let skipSendToRemote = false;
     let extra = {};
     if (args[0].indexOf(CATEGORY_PREFIX) === 0) {
       category = args[0].split('=')[1];
@@ -198,6 +205,7 @@ class IssueReporter {
           errorMessage: lastArg.message,
           errorStack: lastArg.stack,
           errorType: lastArg.constructor.name,
+          skipSendToRemote: lastArg.skipSendToRemote,
         };
       } else {
         extra = lastArg;
@@ -206,6 +214,11 @@ class IssueReporter {
       args.splice(1, 1);
     }
 
+    if (extra.skipSendToRemote) {
+      skipSendToRemote = true;
+      delete extra.skipSendToRemote;
+    }
+
     const date = moment__default['default']().format('YYYY-MM-DD HH:mm:ss.SSS');
     const message = args.join(', ');
     let consoleMessage = message;
@@ -226,7 +239,13 @@ class IssueReporter {
     const oldMethod = this.oldConsoleMethods[consoleLevel] || this.oldConsoleMethods.log;
     oldMethod.apply(oldMethod, [date, consoleMessage]);
 
-    this._sendToRemoteLogger(level, { date, message, category, ...extra });
+    if (this._callback) {
+      this._callback(level, consoleMessage);
+    }
+
+    if (!skipSendToRemote) {
+      this._sendToRemoteLogger(level, { date, message, category, ...extra });
+    }
   }
 
   logRequest(url        , options        , response        , start      ) {
@@ -371,7 +390,11 @@ class IssueReporter {
       },
       // $FlowFixMe
       body,
-    }).catch(() => {
+    }).catch((e       ) => {
+      // $FlowFixMe
+      e.skipSendToRemote = true;
+      this.log('error', this._makeCategory('grafana'), 'Sending log to grafana, error', e);
+
       setTimeout(() => {
         if (isArray) {
           payload = payload.map(message => {
@@ -588,6 +611,7 @@ const AGENT_PAUSED = 'agent_paused';
 const AGENT_UNPAUSED = 'agent_unpaused';
 const CONFERENCE_ADHOC_PARTICIPANT_LEFT = 'conference_adhoc_participant_left';
 const CONFERENCE_ADHOC_DELETED = 'conference_adhoc_deleted';
+const MEETING_USER_PROGRESS = 'meeting_user_progress';
 
 const BLACKLIST_EVENTS = [
   CHAT_MESSAGE_SENT,
@@ -597,7 +621,7 @@ const BLACKLIST_EVENTS = [
 ];
 
 const HEARTBEAT_ENGINE_VERSION = '20.09';
-const logger = IssueReporter$1.loggerFor('wazo-ws');
+const logger$1 = IssueReporter$1.loggerFor('wazo-ws');
 const messageLogger = IssueReporter$1.loggerFor('wazo-ws-message');
 
 class WebSocketClient extends Emitter {
@@ -646,19 +670,19 @@ class WebSocketClient extends Emitter {
   }
 
   connect() {
-    logger.info('connect method started', { host: this.host, token: this.token });
+    logger$1.info('connect method started', { host: this.host, token: this.token });
     this.socket = new ReconnectingWebSocket__default['default'](this._getUrl.bind(this), [], this.options);
     if (this.options.binaryType) {
       this.socket.binaryType = this.options.binaryType;
     }
 
     this.socket.onopen = () => {
-      logger.info('on Wazo WS open', { method: 'connect', host: this.host });
+      logger$1.info('on Wazo WS open', { method: 'connect', host: this.host });
       this.eventEmitter.emit(SOCKET_EVENTS.ON_OPEN);
     };
 
     this.socket.onerror = event => {
-      logger.error('on Wazo WS error', event.target);
+      logger$1.error('on Wazo WS error', event.target);
       this.eventEmitter.emit(SOCKET_EVENTS.ON_ERROR, event);
     };
 
@@ -688,7 +712,7 @@ class WebSocketClient extends Emitter {
 
     this.socket.onclose = event => {
       // Can't be converted to JSON (circular structure)
-      logger.info('on Wazo WS close', {
+      logger$1.info('on Wazo WS close', {
         reason: event.reason,
         code: event.code,
         readyState: event.target.readyState,
@@ -706,12 +730,12 @@ class WebSocketClient extends Emitter {
     };
 
     this.socket.onerror = event => {
-      logger.info('Wazo WS error', { message: event.message, code: event.code, readyState: event.target.readyState });
+      logger$1.info('Wazo WS error', { message: event.message, code: event.code, readyState: event.target.readyState });
     };
   }
 
   close(force          = false)       {
-    logger.info('Wazo WS close', { socket: !!this.socket, host: this.host, token: this.token });
+    logger$1.info('Wazo WS close', { socket: !!this.socket, host: this.host, token: this.token });
 
     if (!this.socket) {
       return;
@@ -729,7 +753,7 @@ class WebSocketClient extends Emitter {
 
   updateToken(token        ) {
     this.token = token;
-    logger.info('Wazo WS updating token', { url: this._getUrl(), token, socket: !!this.socket });
+    logger$1.info('Wazo WS updating token', { url: this._getUrl(), token, socket: !!this.socket });
 
     if (this.socket) {
       // If still connected, send the token to the WS
@@ -747,7 +771,7 @@ class WebSocketClient extends Emitter {
   }
 
   startHeartbeat() {
-    logger.info('Wazo WS start heartbeat', { host: this.host, token: this.token });
+    logger$1.info('Wazo WS start heartbeat', { host: this.host, token: this.token });
 
     if (!this.socket) {
       this.heartbeat.stop();
@@ -761,7 +785,7 @@ class WebSocketClient extends Emitter {
   }
 
   stopHeartbeat() {
-    logger.info('Wazo WS stop heartbeat', { host: this.host, token: this.token });
+    logger$1.info('Wazo WS stop heartbeat', { host: this.host, token: this.token });
 
     this.heartbeat.stop();
   }
@@ -791,7 +815,7 @@ class WebSocketClient extends Emitter {
   }
 
   reconnect(reason        ) {
-    logger.info('Wazo WS reconnect', { reason, socket: !!this.socket, host: this.host, token: this.token });
+    logger$1.info('Wazo WS reconnect', { reason, socket: !!this.socket, host: this.host, token: this.token });
     if (!this.socket) {
       return;
     }
@@ -847,7 +871,7 @@ class WebSocketClient extends Emitter {
       this.close();
     }
     const url = `wss://${this.host || ''}/api/websocketd/?token=${this.token || ''}&version=${this.version}`;
-    logger.log('Wazo WS url computed to reconnect', { url });
+    logger$1.log('Wazo WS url computed to reconnect', { url });
 
     return url;
   }
@@ -855,12 +879,12 @@ class WebSocketClient extends Emitter {
   _onHeartbeat(message        ) {
     if (message.payload === 'pong') {
       this.heartbeat.onHeartbeat();
-      logger.log('on heartbeat received from Wazo WS');
+      logger$1.log('on heartbeat received from Wazo WS');
     }
   }
 
   async _onHeartbeatTimeout() {
-    logger.log('heartbeat timed out', { host: this.host, token: this.token });
+    logger$1.log('heartbeat timed out', { host: this.host, token: this.token });
 
     this.close();
     this.eventEmitter.emit(SOCKET_EVENTS.ON_CLOSE, new Error('Websocket ping failure.'));
@@ -938,6 +962,7 @@ WebSocketClient.eventLists = [
   AGENT_UNPAUSED,
   CONFERENCE_ADHOC_PARTICIPANT_LEFT,
   CONFERENCE_ADHOC_DELETED,
+  MEETING_USER_PROGRESS,
 ];
 
 exports.AGENT_PAUSED = AGENT_PAUSED;
@@ -993,6 +1018,7 @@ exports.HEARTBEAT_ENGINE_VERSION = HEARTBEAT_ENGINE_VERSION;
 exports.LINE_STATUS_UPDATED = LINE_STATUS_UPDATED;
 exports.MEETING_USER_PARTICIPANT_JOINED = MEETING_USER_PARTICIPANT_JOINED;
 exports.MEETING_USER_PARTICIPANT_LEFT = MEETING_USER_PARTICIPANT_LEFT;
+exports.MEETING_USER_PROGRESS = MEETING_USER_PROGRESS;
 exports.SOCKET_EVENTS = SOCKET_EVENTS;
 exports.SWITCHBOARD_HELD_CALLS_UPDATED = SWITCHBOARD_HELD_CALLS_UPDATED;
 exports.SWITCHBOARD_HELD_CALL_ANSWERED = SWITCHBOARD_HELD_CALL_ANSWERED;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wazo/sdk",
-  "version": "0.37.20",
+  "version": "0.37.24",
   "description": "Wazo's JavaScript Software Development Kit.",
   "main": "dist/wazo-sdk.js",
   "author": "Wazo (http://wazo.io)",

package/src/api/confd.js

@@ -69,8 +69,11 @@ export default (client: ApiRequester, baseUrl: string) => ({
     }
   },
 
-  createMyMeeting: (name: string): Promise<Meeting> =>
-    client.post(`${baseUrl}/users/me/meetings`, { name }).then(Meeting.parse),
+  getMyMeetings: (): Promise<Meeting> =>
+    client.get(`${baseUrl}/users/me/meetings`).then(response => Meeting.parseMany(response.items)),
+
+  createMyMeeting: (name: string, persistent: boolean): Promise<Meeting> =>
+    client.post(`${baseUrl}/users/me/meetings`, { name, persistent }).then(Meeting.parse),
 
   deleteMyMeeting: (meetingUuid: string): Promise<Meeting> =>
     client.delete(`${baseUrl}/users/me/meetings/${meetingUuid}`, null),

package/src/domain/Call.js

@@ -61,6 +61,9 @@ export default class Call {
   recording: boolean;
 
   static parseMany(plain: Array<CallResponse>): Array<Call> {
+    if (!plain) {
+      return [];
+    }
     return plain.map((plainCall: CallResponse) => Call.parse(plainCall));
   }
 

package/src/domain/CallLog.js

@@ -84,6 +84,10 @@ export default class CallLog {
   }
 
   static parseMany(plain: Response): Array<CallLog> {
+    if (!plain || !plain.items) {
+      return [];
+    }
+
     return plain.items.map(item => CallLog.parse(item));
   }
 

package/src/domain/ChatMessage.js

@@ -42,6 +42,10 @@ export default class ChatMessage {
   read: boolean;
 
   static parseMany(plain: ChatMessageListResponse): Array<ChatMessage> {
+    if (!plain || !plain.items) {
+      return [];
+    }
+
     return plain.items.map(item => ChatMessage.parse(item));
   }
 

package/src/domain/ChatRoom.js

@@ -22,6 +22,9 @@ export default class ChatRoom {
   users: Array<ChatUser>;
 
   static parseMany(plain: RootListResponse): Array<ChatRoom> {
+    if (!plain || !plain.items) {
+      return [];
+    }
     return plain.items.map(item => ChatRoom.parse(item));
   }
 

package/src/domain/Contact.js

@@ -281,6 +281,9 @@ export default class Contact {
   }
 
   static parseMany(response: ContactsResponse): Array<Contact> {
+    if (!response || !response.results) {
+      return [];
+    }
     return response.results.map(r => Contact.parse(r, response.column_types));
   }
 

package/src/domain/Meeting.js

@@ -1,4 +1,6 @@
 // @flow
+import moment from 'moment';
+
 import newFrom from '../utils/new-from';
 
 export type MeetingCreationResponse = {
@@ -8,8 +10,9 @@ export type MeetingCreationResponse = {
   owner_uuids: Array<string>,
   port: string,
   uuid: string,
-  number: string,
+  exten: string,
   persistent: boolean,
+  creation_time: string,
 }
 
 export default class Meeting {
@@ -20,9 +23,10 @@ export default class Meeting {
   uuid: string;
   name: string;
   port: string;
-  number: string;
+  extension: string;
   persistent: boolean;
   ownerUuids: Array<string>;
+  creationTime: Date;
 
   static parse(plain: MeetingCreationResponse): Meeting {
     return new Meeting({
@@ -32,24 +36,43 @@ export default class Meeting {
       ownerUuids: plain.owner_uuids,
       port: plain.port,
       uuid: plain.uuid,
-      number: plain.number,
+      extension: plain.exten,
       persistent: plain.persistent,
+      creationTime: moment(plain.creation_time).toDate(),
     });
   }
 
+  static parseMany(items: MeetingCreationResponse[]): Array<Meeting> {
+    if (!items) {
+      return [];
+    }
+    return items.map(plain => Meeting.parse(plain));
+  }
+
   static newFrom(meeting: Meeting) {
     return newFrom(meeting, Meeting);
   }
 
-  constructor({ uuid, name, guestSipAuthorization, ownerUuids, port, uri, number, persistent }: Object = {}) {
+  constructor({
+    uuid,
+    name,
+    guestSipAuthorization,
+    ownerUuids,
+    port,
+    uri,
+    extension,
+    persistent,
+    creationTime,
+  }: Object = {}) {
     this.guestSipAuthorization = guestSipAuthorization;
     this.uri = uri;
     this.name = name;
     this.ownerUuids = ownerUuids;
     this.port = port;
     this.uuid = uuid;
-    this.number = number;
+    this.extension = extension;
     this.persistent = persistent;
+    this.creationTime = creationTime;
 
     // Useful to compare instead of instanceof with minified code
     this.type = 'Meeting';

package/src/domain/Phone/CTIPhone.js

@@ -280,6 +280,10 @@ export default class CTIPhone extends Emitter implements Phone {
     return false;
   }
 
+  hasAVideoTrack(): boolean {
+    return false;
+  }
+
   getLocalStreamForCall(): ?MediaStream {
     return null;
   }

package/src/domain/Phone/Phone.js

@@ -80,6 +80,8 @@ export interface Phone {
 
   hasVideo(callSession: CallSession): boolean;
 
+  hasAVideoTrack(callSession: CallSession): boolean;
+
   isWebRTC(): boolean;
 
   getUserAgent(): string;

package/src/domain/Phone/WebRTCPhone.js

@@ -306,6 +306,11 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
     this.client.downgradeToAudio(sipSession);
 
+    if (callSession) {
+      callSession.cameraEnabled = false;
+      this._updateCallSession(callSession);
+    }
+
     if (withMessage) {
       this._sendReinviteMessage(callSession, false);
     }
@@ -333,6 +338,11 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
     const newStream = await this.client.upgradeToVideo(sipSession, constraints, isConference);
 
+    if (callSession) {
+      callSession.cameraEnabled = true;
+      this._updateCallSession(callSession);
+    }
+
     // If no stream is returned, it means we have to reinvite
     if (!newStream) {
       return true;
@@ -385,7 +395,10 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
         onCancel(message);
         const elsewhere = message.data.indexOf('cause=26') !== -1 && message.data.indexOf('completed elsewhere') !== -1;
-        this.eventEmitter.emit(ON_CALL_CANCELED, this._createCallSession(sipSession), elsewhere);
+        const callSession = this._createCallSession(sipSession);
+        delete this.callSessions[callSession.getId()];
+
+        this.eventEmitter.emit(ON_CALL_CANCELED, callSession, elsewhere);
       };
     } else if (sipSession instanceof Invitation) {
       console.warn('sipSession._onCancel not found, please update the wazo SDK accordingly');
@@ -414,9 +427,11 @@ export default class WebRTCPhone extends Emitter implements Phone {
         case SessionState.Terminated: {
           logger.info('WebRTC phone - call terminated', { sipId: sipSession.id });
 
+          // Should be called before `_onCallTerminated` or the callCount will not decrement...
+          const callSession = this._createCallSession(sipSession);
           const wasCurrentSession = this._onCallTerminated(sipSession);
 
-          return this.eventEmitter.emit(ON_CALL_ENDED, this._createCallSession(sipSession), wasCurrentSession);
+          return this.eventEmitter.emit(ON_CALL_ENDED, callSession, wasCurrentSession);
         }
         default:
           break;
@@ -566,18 +581,20 @@ export default class WebRTCPhone extends Emitter implements Phone {
       screenTrack,
     });
 
-    screenTrack.onended = () => {
-      logger.info('WebRTC phone - on screenshare ended', {
-        hadVideo,
-        id: this.getSipSessionId(sipSession),
-        screenTrack,
-      });
-
-      this.eventEmitter.emit(
-        ON_SHARE_SCREEN_ENDING,
-        this._createCallSession(sipSession, callSession),
-      );
-    };
+    if (screenTrack) {
+      screenTrack.onended = () => {
+        logger.info('WebRTC phone - on screenshare ended', {
+          hadVideo,
+          id: this.getSipSessionId(sipSession),
+          screenTrack,
+        });
+
+        this.eventEmitter.emit(
+          ON_SHARE_SCREEN_ENDING,
+          this._createCallSession(sipSession, callSession),
+        );
+      };
+    }
 
     this.currentScreenShare = {
       stream: screenStream,
@@ -1366,6 +1383,10 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return callSession ? this.client.getRemoteVideoStream(callSession.sipCallId) : null;
   }
 
+  getRemoteVideoStreamFromPc(callSession: CallSession): ?MediaStream {
+    return callSession ? this.client.getRemoteVideoStreamFromPc(callSession.sipCallId) : null;
+  }
+
   hasRemoteVideo(callSession: CallSession): boolean {
     return callSession ? this.client.hasRemoteVideo(callSession.sipCallId) : false;
   }
@@ -1466,9 +1487,13 @@ export default class WebRTCPhone extends Emitter implements Phone {
       if (this.shouldSendReinvite && this.currentSipSession
         && this.currentSipSession.state === SessionState.Established) {
         this.shouldSendReinvite = false;
+        const pc = this.currentSipSession.sessionDescriptionHandler.peerConnection;
+        const isConference = pc ? pc.sfu : false;
+        const hasVideo = this.currentCallSession && this.currentCallSession.cameraEnabled;
+
         try {
           // Send reinvite with iceRestart
-          this.sendReinvite(this.currentCallSession, null, false, false, true);
+          this.sendReinvite(this.currentCallSession, null, isConference, !hasVideo, true);
         } catch (e) {
           logger.error('WebRTC reinvite after register, error', { message: e.message, stack: e.stack });
         }
@@ -1552,6 +1577,15 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return this.client.getSipSessionId(sipSession);
   }
 
+  _updateCallSession(callSession: CallSession) {
+    const sipSession = this.findSipSession(callSession);
+    const sipSessionId = sipSession ? this.getSipSessionId(sipSession) : null;
+
+    if (sipSessionId) {
+      this.callSessions[sipSessionId] = callSession;
+    }
+  }
+
   _onMessage(message: Message) {
     if (!message || message.method !== 'MESSAGE') {
       return;

package/src/domain/Recording.js

@@ -25,6 +25,9 @@ export default class Recording {
   uuid: string;
 
   static parseMany(recordings: RecordingResponse[] = []): Recording[] {
+    if (!recordings) {
+      return [];
+    }
     return recordings.map(item => Recording.parse(item));
   }
 

package/src/domain/Voicemail.js

@@ -61,6 +61,9 @@ export default class Voicemail {
   }
 
   static parseMany(plain: Response): Array<Voicemail> {
+    if (!plain) {
+      return [];
+    }
     const plainUnread = plain.folders.filter(folder => folder.type === 'new')[0].messages;
     const plainRead = plain.folders.filter(folder => folder.type === 'old')[0].messages;
 

package/src/domain/__tests__/Meeting.test.js

@@ -0,0 +1,50 @@
+// @flow
+/* global btoa */
+
+import Meeting from '../Meeting';
+
+describe('Meeting domain', () => {
+  it('can return username and secret from an base64 encrypted string', () => {
+    const USERNAME = 'username';
+    const SECRET = 'secret';
+
+    const args = {
+      guest_sip_authorization: btoa(`${USERNAME}:${SECRET}`),
+      creation_time: '',
+      ingress_http_uri: '',
+      name: '',
+      owner_uuids: [],
+      port: '',
+      uuid: '',
+      exten: '',
+      persistent: false,
+    };
+
+    const meeting = Meeting.parse(args);
+
+    const { username, secret } = meeting.getGuestSipCredentials();
+
+    expect(username).toEqual(USERNAME);
+    expect(secret).toEqual(SECRET);
+  });
+
+  it('should return a date from a string', () => {
+    const args = {
+      creation_time: '2021-12-21T15:56:42.880Z',
+      guest_sip_authorization: '',
+      ingress_http_uri: '',
+      name: '',
+      owner_uuids: [],
+      port: '',
+      uuid: '',
+      exten: '',
+      persistent: false,
+    };
+
+    const { creationTime } = Meeting.parse(args);
+
+    expect(creationTime.getDate()).toEqual(21);
+    expect(creationTime.getFullYear()).toEqual(2021);
+    expect(creationTime.getMonth()).toEqual(11);
+  });
+});

package/src/lib/WazoSessionDescriptionHandler.js

@@ -12,11 +12,9 @@ import { SessionDescriptionHandler }
 import { SessionDescriptionHandlerOptions }
   from 'sip.js/lib/platform/web/session-description-handler/session-description-handler-options';
 import IssueReporter from '../service/IssueReporter';
-import { areCandidateValid, fixSdp, parseCandidate } from '../utils/sdp';
+import { fixSdp, parseCandidate } from '../utils/sdp';
 
 const wazoLogger = IssueReporter ? IssueReporter.loggerFor('webrtc-sdh') : console;
-const MAX_WAIT_FOR_ICE_TRIES = 20;
-const WAIT_FOR_ICE_TIMEOUT = 500;
 
 // Customized mediaStreamFactory allowing to send screensharing stream directory when upgrading
 export const wazoMediaStreamFactory = (constraints: Object): Promise<MediaStream> => {
@@ -206,38 +204,6 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
     this._peerConnection = undefined;
   }
 
-  async _waitForValidGatheredIce(): Object {
-    let tries = 0;
-
-    while (!areCandidateValid(this.gatheredCandidates) && tries < MAX_WAIT_FOR_ICE_TRIES) {
-      wazoLogger.trace('SessionDescriptionHandler._waitForValidGatheredIce, waiting for ice', {
-        tries,
-        max: MAX_WAIT_FOR_ICE_TRIES,
-      });
-
-      tries++;
-
-      // eslint-disable-next-line no-await-in-loop
-      await new Promise(resolve => setTimeout(resolve, WAIT_FOR_ICE_TIMEOUT));
-    }
-
-    if (tries >= MAX_WAIT_FOR_ICE_TRIES) {
-      const errorMsg = 'No valid candidates found, can\'t answer the call';
-      const error = new Error(errorMsg);
-      wazoLogger.error(errorMsg, { tries, max: MAX_WAIT_FOR_ICE_TRIES });
-
-      // Emit an error, because sip.js catches the exception and switch to status Terminated.
-      this.eventEmitter.emit('error', error);
-
-      wazoLogger.error('No valid candidates found', { tries, candidates: JSON.stringify(this.gatheredCandidates) });
-    }
-
-    // eslint-disable-next-line
-    wazoLogger.trace('Found valid candidates', { tries, candidates: JSON.stringify(this.gatheredCandidates) });
-
-    return this.getLocalSessionDescription();
-  }
-
   // Overridden to send `inactive` in conference
   updateDirection(options?: SessionDescriptionHandlerOptions, isConference: boolean = false,
     audioOnly: boolean = false): Promise<void> {