@wazo/sdk 0.37.0-rc.5 → 0.37.2

package/src/simple/room/Room.js

@@ -415,13 +415,15 @@ class Room extends Emitter {
       }
     });
 
-    this.on(this.ON_VIDEO_STREAM, (stream, streamId) => {
+    this.on(this.ON_VIDEO_STREAM, (stream, streamId, event, sipSession) => {
       logger.info('on room video stream', { streamId });
 
+      this._mapMsid(sipSession.body.body);
+
       // ON_VIDEO_STREAM is called before PARTICIPANT_JOINED, so we have to keep stream in `_unassociatedVideoStreams`.
       this._unassociatedVideoStreams[streamId] = stream;
 
-      const callId = this._getCallIdFromStreamId(streamId);
+      const callId = this._getCallIdFromTrackId(streamId);
       const participant = callId ? this._getParticipantFromCallId(callId) : null;
       if (participant) {
         this.__associateStreams(participant);
@@ -465,11 +467,12 @@ class Room extends Emitter {
     const sdp = sdpParser.parse(rawSdp);
     const labelMsidArray = sdp.media.filter(media => !!media.label).map(({ label, msid }) => ({
       label: String(label),
-      msid: msid.split(' ')[1],
+      streamId: msid.split(' ')[0],
+      trackId: msid.split(' ')[1],
     }));
 
-    labelMsidArray.forEach(({ label, msid }) => {
-      this._callIdStreamIdMap[String(label)] = msid;
+    labelMsidArray.forEach(({ label, streamId, trackId }) => {
+      this._callIdStreamIdMap[String(label)] = { streamId, trackId };
 
       const callId = String(label);
       const participant = this._unassociatedParticipants[callId] || this._getParticipantFromCallId(callId);
@@ -701,9 +704,9 @@ class Room extends Emitter {
   _onParticipantTrackUpdate(oldParticipant: Participant, update: string): Participant {
     const newParticipant = oldParticipant;
 
-    const label = this._callIdStreamIdMap[newParticipant.callId];
+    const { trackId } = this._callIdStreamIdMap[newParticipant.callId] || {};
     const pc = Wazo.Phone.phone.currentSipSession.sessionDescriptionHandler.peerConnection;
-    const stream = pc.getRemoteStreams().find(otherStream => otherStream.getTracks().some(track => track.id === label));
+    const stream = pc.getRemoteStreams().find(someStream => someStream.getTracks().some(track => track.id === trackId));
 
     if (update === 'downgrade') {
       newParticipant.streams = [];
@@ -723,21 +726,21 @@ class Room extends Emitter {
 
   // Associate audio/video streams to the participant and triggers events on it
   __associateStreams(participant: Participant) {
-    const streamId = this._callIdStreamIdMap[participant.callId];
-    if (!streamId) {
+    const { trackId } = this._callIdStreamIdMap[participant.callId] || {};
+    if (!trackId) {
       this._unassociatedParticipants[participant.callId] = participant;
 
       return;
     }
-    if (!streamId || !participant || !this.localParticipant || participant.callId === this.localParticipant.callId) {
+    if (!trackId || !participant || !this.localParticipant || participant.callId === this.localParticipant.callId) {
       return;
     }
 
-    if (this._unassociatedVideoStreams[streamId]) {
+    if (this._unassociatedVideoStreams[trackId]) {
       // Try to associate stream
-      this._associateStreamTo(this._unassociatedVideoStreams[streamId], participant);
+      this._associateStreamTo(this._unassociatedVideoStreams[trackId], participant);
 
-      delete this._unassociatedVideoStreams[streamId];
+      delete this._unassociatedVideoStreams[trackId];
       delete this._unassociatedParticipants[participant.callId];
     }
   }
@@ -750,8 +753,8 @@ class Room extends Emitter {
     participant.onStreamSubscribed(stream);
   }
 
-  _getCallIdFromStreamId(streamId: string) {
-    return Object.keys(this._callIdStreamIdMap).find(key => this._callIdStreamIdMap[key] === streamId);
+  _getCallIdFromTrackId(trackId: string) {
+    return Object.keys(this._callIdStreamIdMap).find(key => this._callIdStreamIdMap[key].trackId === trackId);
   }
 
   _getParticipantFromCallId(callId: string) {

package/src/simple/room/Stream.js

@@ -34,10 +34,7 @@ class Stream {
     element.onloadedmetadata = () => {
       const tracks = this.htmlStream ? this.htmlStream.getVideoTracks() : [];
       tracks.forEach(track => {
-        // Do not re-enable the track if already mounted.
-        if (!track.loaded) {
-          track.enabled = true;
-        }
+        track.enabled = true;
         // $FlowFixMe
         track.loaded = true;
       });

package/src/utils/__tests__/api-requester.test.js

@@ -50,11 +50,16 @@ describe('Retrieving headers', () => {
 });
 
 describe('Calling fetch', () => {
-  it('should call fetch without body but query string in get method', () => {
+  it('should call fetch without body but query string in get method', async () => {
     jest.mock('node-fetch/lib/index', () => {});
-    global.fetch = jest.fn(() => Promise.resolve({ json: () => Promise.resolve({}) }));
-
-    new ApiRequester({ server }).call(path, method, body, {});
+    global.fetch = jest.fn(() => Promise.resolve({
+      json: () => Promise.resolve({}),
+      headers: {
+        get: () => '',
+      },
+    }));
+
+    await new ApiRequester({ server }).call(path, method, body, {});
     expect(global.fetch).toBeCalledWith(url, { method: 'get', body: null, headers: {}, agent: null });
   });
 });

package/src/utils/api-requester.js

@@ -56,6 +56,7 @@ export default class ApiRequester {
   fetchOptions: Object;
   refreshTokenCallback: Function;
   refreshTokenPromise: ?Promise<any>;
+  shouldLogErrors: boolean;
 
   head: Function;
   get: Function;
@@ -95,6 +96,8 @@ export default class ApiRequester {
       this.token = token;
     }
 
+    this.shouldLogErrors = true;
+
     methods.forEach(method => {
       // $FlowFixMe
       ApiRequester.prototype[method] = function sugar(...args) {
@@ -118,6 +121,14 @@ export default class ApiRequester {
     this.fetchOptions = options;
   }
 
+  disableErrorLogging() {
+    this.shouldLogErrors = false;
+  }
+
+  enableErrorLogging() {
+    this.shouldLogErrors = true;
+  }
+
   async call(
     path: string,
     method: string = 'get',
@@ -178,7 +189,9 @@ export default class ApiRequester {
             ? exceptionClass.fromText(err, response.status)
             : exceptionClass.fromResponse(err, response.status);
 
-          logger.error('API error', error);
+          if (this.shouldLogErrors) {
+            logger.error('API error', error);
+          }
 
           throw error;
         });
@@ -186,7 +199,9 @@ export default class ApiRequester {
 
       return newParse(response, isJson);
     }).catch(error => {
-      logger.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+      if (this.shouldLogErrors) {
+        logger.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+      }
 
       throw error;
     });

package/src/web-rtc-client.js

@@ -15,12 +15,11 @@ import type SessionDescriptionHandlerConfiguration
 import type SessionDescriptionHandler
   from 'sip.js/lib/platform/web/session-description-handler/session-description-handler';
 import { UserAgentState } from 'sip.js/lib/api/user-agent-state';
-import { Message } from 'sip.js/lib/api/message';
 import { Parser } from 'sip.js/lib/core/messages/parser';
 import { C } from 'sip.js/lib/core/messages/methods/constants';
 import { URI } from 'sip.js/lib/grammar/uri';
 import { UserAgent } from 'sip.js/lib/api/user-agent';
-import { holdModifier } from 'sip.js/lib/platform/web/modifiers/modifiers';
+import { holdModifier, stripVideo } from 'sip.js/lib/platform/web/modifiers/modifiers';
 import { Registerer } from 'sip.js/lib/api/registerer';
 import { Inviter } from 'sip.js/lib/api/inviter';
 import { Messager } from 'sip.js/lib/api/messager';
@@ -37,7 +36,7 @@ import Emitter from './utils/Emitter';
 import ApiClient from './api-client';
 import IssueReporter from './service/IssueReporter';
 import Heartbeat from './utils/Heartbeat';
-import { deactivateVideoModifier, hasAnActiveVideo } from './utils/sdp';
+import { hasAnActiveVideo } from './utils/sdp';
 
 // We need to replace 0.0.0.0 to 127.0.0.1 in the sdp to avoid MOH during a createOffer.
 export const replaceLocalIpModifier = (description: Object) => Promise.resolve({
@@ -432,9 +431,15 @@ export default class WebRTCClient extends Emitter {
 
   call(number: string, enableVideo?: boolean, audioOnly: boolean = false, conference: boolean = false): Session {
     logger.info('sdk webrtc creating call', { number, enableVideo, audioOnly });
-    const inviterOptions = {};
+    const inviterOptions: Object = {
+      sessionDescriptionHandlerOptionsReInvite: {
+        conference,
+        audioOnly,
+      },
+    };
+
     if (audioOnly) {
-      inviterOptions.sessionDescriptionHandlerModifiersReInvite = [deactivateVideoModifier];
+      inviterOptions.sessionDescriptionHandlerModifiersReInvite = [stripVideo];
     }
 
     const session = new Inviter(this.userAgent, this._makeURI(number), inviterOptions);
@@ -463,10 +468,11 @@ export default class WebRTCClient extends Emitter {
       sessionDescriptionHandlerOptions: this.getMediaConfiguration(enableVideo || false, conference),
     };
 
-    inviteOptions.sessionDescriptionHandlerModifiers = [replaceLocalIpModifier];
+    inviteOptions.sessionDescriptionHandlerOptions.audioOnly = audioOnly;
 
+    inviteOptions.sessionDescriptionHandlerModifiers = [replaceLocalIpModifier];
     if (audioOnly) {
-      inviteOptions.sessionDescriptionHandlerModifiers.push(deactivateVideoModifier);
+      inviteOptions.sessionDescriptionHandlerModifiers.push(stripVideo);
     }
 
     // Do not await invite here or we'll miss the Establishing state transition
@@ -680,6 +686,9 @@ export default class WebRTCClient extends Emitter {
     if (!this._isWeb()) {
       options.sessionDescriptionHandlerModifiers = [holdModifier];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -719,6 +728,9 @@ export default class WebRTCClient extends Emitter {
       // (eg: holdModifier)
       options.sessionDescriptionHandlerModifiers = [];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -948,7 +960,8 @@ export default class WebRTCClient extends Emitter {
       ? this.video.deviceId.exact : undefined;
   }
 
-  reinvite(sipSession: Session, newConstraints: ?Object = null, conference: boolean = false) {
+  reinvite(sipSession: Session, newConstraints: ?Object = null, conference: boolean = false,
+    audioOnly: boolean = false) {
     if (!sipSession) {
       return false;
     }
@@ -958,16 +971,17 @@ export default class WebRTCClient extends Emitter {
     }
 
     const wasMuted = this.isAudioMuted(sipSession);
-    // When upgrading to video, remove the `deactivateVideoModifier` modifiers
+    // When upgrading to video, remove the `stripVideo` modifiers
     if (newConstraints && newConstraints.video) {
       const modifiers = sipSession.sessionDescriptionHandlerModifiersReInvite;
       sipSession.sessionDescriptionHandlerModifiersReInvite = modifiers.filter(modifier =>
-        modifier !== deactivateVideoModifier);
+        modifier !== stripVideo);
     }
 
     sipSession.sessionDescriptionHandlerOptionsReInvite = {
       ...sipSession.sessionDescriptionHandlerOptionsReInvite,
       conference,
+      audioOnly,
     };
 
     const shouldDoVideo = newConstraints ? newConstraints.video : this.sessionWantsToDoVideo(sipSession);
@@ -1007,6 +1021,8 @@ export default class WebRTCClient extends Emitter {
       },
       sessionDescriptionHandlerOptions: {
         constraints,
+        conference,
+        audioOnly,
         offerOptions: {
           iceRestart: false,
         },
@@ -1466,6 +1482,8 @@ export default class WebRTCClient extends Emitter {
 
   // Invitation and Inviter extends Session
   _setupSession(session: Session) {
+    const sipSessionId = this.getSipSessionId(session);
+
     // When receiving an Invitation, the delegate is not defined.
     if (!session.delegate) {
       session.delegate = {};
@@ -1489,8 +1507,18 @@ export default class WebRTCClient extends Emitter {
       };
     };
 
+    const oldInviteRequest = session.onInviteRequest.bind(session);
+    let hadRemoteVideo = false;
+
+    // Monkey patch `onInviteRequest` to be able to know if there was a remote video stream before `onInvite` is called
+    // Becase when `onInvite` is called we already got the video track
+    session.onInviteRequest = (request) => {
+      hadRemoteVideo = this.hasARemoteVideoTrack(sipSessionId);
+
+      oldInviteRequest(request);
+    };
+
     session.delegate.onInvite = (request: IncomingRequestMessage) => {
-      const sipSessionId = this.getSipSessionId(session);
       let updatedCalleeName = null;
       let updatedNumber = null;
       if (session.assertedIdentity) {
@@ -1500,7 +1528,6 @@ export default class WebRTCClient extends Emitter {
       logger.info('re-invite received', { updatedCalleeName, updatedNumber });
 
       // Useful to know if it's a video upgrade or an unhold from a remote peer with a video stream
-      const hadRemoteVideo = this.hasARemoteVideoTrack(sipSessionId);
 
       // Update SDP
       // Remote video is handled by the `track` event. Here we're dealing with video stream removal.
@@ -1550,7 +1577,7 @@ export default class WebRTCClient extends Emitter {
   }
 
   _isAudioOnly(session: Session): boolean {
-    return session.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === deactivateVideoModifier);
+    return session.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === stripVideo);
   }
 
   _setupMedias(session: Session, newStream: ?MediaStream) {