@wazo/sdk 0.37.2 → 0.37.6

package/src/simple/room/SipRoom.js

@@ -0,0 +1,147 @@
+// @flow
+
+import type { Message } from 'sip.js/lib/api/message';
+import IssueReporter from '../../service/IssueReporter';
+import Wazo from '../index';
+import Room from './Room';
+
+const logger = IssueReporter.loggerFor('sdk-sip-room');
+
+class SipRoom extends Room {
+
+  static async connect({ extension, constraints, audioOnly = false, extra, room }: Object) {
+    logger.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.info('connected to room', {
+      extension: room.extension,
+    });
+
+    return room;
+  }
+
+  mute() {
+    logger.info('mute sip room');
+
+    Wazo.Phone.mute(this.callSession, false);
+
+    this.sendMuteStatus();
+  }
+
+  unmute() {
+    logger.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: 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;
+      }
+      default:
+        break;
+    }
+  }
+
+  async _onParticipantJoined(channel: Object) {
+    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);
+  }
+
+}
+
+export default SipRoom;

package/src/simple/room/Stream.js

@@ -52,9 +52,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() {

package/src/simple/room/__tests__/RemoteParticipant.test.js

@@ -1,9 +1,10 @@
-import RemoteParticipant from '../RemoteParticipant';
+// Using directly Wazo to avoid issues with require cycle
+import Wazo from '../../index';
 
 describe('RemoteParticipant', () => {
   it('should fall back on number when name is <unknown>', () => {
     const number = '1234';
-    const participant = new RemoteParticipant(null, { caller_id_name: '<unknown>', caller_id_number: number });
+    const participant = new Wazo.RemoteParticipant(null, { caller_id_name: '<unknown>', caller_id_number: number });
     expect(participant.name).toEqual(number);
   });
 });

package/src/types/WebSocketMessage.js

@@ -91,6 +91,17 @@ export type RoomParticipantUpdate = {
   muted: boolean,
   user_uuid: string,
 };
+export type MeetingParticipantUpdate = {
+  admin: boolean,
+  call_id: string,
+  caller_id_name: string,
+  caller_id_number: string,
+  room_uuid: string,
+  id: string,
+  language: string,
+  muted: boolean,
+  user_uuid: string,
+};
 
 export type FaxOutboundFailedEvent = {
   call_id: string,
@@ -145,6 +156,14 @@ type ParticipantLeftRoom = WebSocketBaseMessage & {
   data: RoomParticipantUpdate,
   name: 'conference_user_participant_left',
 };
+type ParticipantJoinedMeeting = WebSocketBaseMessage & {
+  data: MeetingParticipantUpdate,
+  name: 'meeting_user_participant_joined',
+};
+type ParticipantLeftMeeting = WebSocketBaseMessage & {
+  data: MeetingParticipantUpdate,
+  name: 'meeting_user_participant_left',
+};
 type SwitchboardQueuedCallsUpdated = WebSocketBaseMessage & {
   data: SwitchboardCallItems,
   name: 'switchboard_queued_calls_updated',
@@ -194,6 +213,8 @@ export type WebSocketMessage =
   | SwitchboardHeldCallAnswered
   | ParticipantJoinedRoom
   | ParticipantLeftRoom
+  | ParticipantJoinedMeeting
+  | ParticipantLeftMeeting
   | FaxOutboundFailed
   | FaxOutboundSucceeded
   | AgentStatusUpdate

package/src/web-rtc-client.js

@@ -96,6 +96,7 @@ type WebRtcConfig = {
   heartbeatDelay: number,
   heartbeatTimeout: number,
   maxHeartbeats: number,
+  skipRegister: boolean,
 };
 
 // @see https://github.com/onsip/SIP.js/blob/master/src/Web/Simple.js
@@ -121,6 +122,7 @@ export default class WebRTCClient extends Emitter {
   statsIntervals: Object;
   sipSessions: { [string]: Session };
   conferences: { [string]: boolean };
+  skipRegister: boolean;
 
   // sugar
   ON_USER_AGENT: string;
@@ -159,6 +161,8 @@ export default class WebRTCClient extends Emitter {
     super();
     this.uaConfigOverrides = uaConfigOverrides;
     this.config = config;
+    this.skipRegister = config.skipRegister;
+
     this._buildConfig(config, session).then((newConfig: WebRtcConfig) => {
       this.config = newConfig;
       this.userAgent = this.createUserAgent(uaConfigOverrides);
@@ -286,14 +290,22 @@ export default class WebRTCClient extends Emitter {
   }
 
   register(tries: number = 0): Promise<any> {
-    logger.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.info('sdk webrtc skip register...', logInfo);
+      return Promise.resolve();
+    }
+
+    logger.info('sdk webrtc registering...', logInfo);
 
     if (!this.userAgent) {
       logger.info('sdk webrtc recreating User Agent');
@@ -624,12 +636,18 @@ export default 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;
@@ -688,6 +706,8 @@ export default class WebRTCClient extends Emitter {
     }
     options.sessionDescriptionHandlerOptions = {
       constraints: options.constraints,
+      hold: true,
+      conference: isConference,
     };
 
     // Send re-INVITE
@@ -730,6 +750,8 @@ export default class WebRTCClient extends Emitter {
     }
     options.sessionDescriptionHandlerOptions = {
       constraints: options.constraints,
+      hold: false,
+      conference: isConference,
     };
 
     // Send re-INVITE
@@ -913,7 +935,8 @@ export default 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) {
@@ -939,11 +962,8 @@ export default 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;
     });
   }
@@ -1245,9 +1265,11 @@ export default 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: boolean, conference: boolean = false, constraints: ?Object = null): Object {
@@ -1282,6 +1304,25 @@ export default class WebRTCClient extends Emitter {
     return sessionId in this.conferences;
   }
 
+  createAudioElementFor(sessionId: string) {
+    const audio: any = 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();
@@ -1511,7 +1552,7 @@ export default 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);
 
@@ -1586,20 +1627,10 @@ export default class WebRTCClient extends Emitter {
     const isConference = this.isConference(sessionId);
 
     if (this._hasAudio() && this._isWeb() && !(sessionId in this.audioElements)) {
-      const audio: any = 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) {

package/src/websocket-client.js

@@ -59,6 +59,8 @@ export const CONFERENCE_USER_PARTICIPANT_JOINED = 'conference_user_participant_j
 export const CONFERENCE_USER_PARTICIPANT_LEFT = 'conference_user_participant_left';
 export const CONFERENCE_USER_PARTICIPANT_TALK_STARTED = 'conference_user_participant_talk_started';
 export const CONFERENCE_USER_PARTICIPANT_TALK_STOPPED = 'conference_user_participant_talk_stopped';
+export const MEETING_USER_PARTICIPANT_JOINED = 'meeting_user_participant_joined';
+export const MEETING_USER_PARTICIPANT_LEFT = 'meeting_user_participant_left';
 export const SWITCHBOARD_QUEUED_CALLS_UPDATED = 'switchboard_queued_calls_updated';
 export const SWITCHBOARD_QUEUED_CALL_ANSWERED = 'switchboard_queued_call_answered';
 export const SWITCHBOARD_HELD_CALLS_UPDATED = 'switchboard_held_calls_updated';
@@ -408,6 +410,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,