@wazo/sdk 0.39.0-beta.8 → 0.39.0

package/src/web-rtc-client.ts

@@ -8,7 +8,6 @@ import type { InvitationRejectOptions } from 'sip.js/lib/api/invitation-reject-o
 import type { InviterCancelOptions } from 'sip.js/lib/api/inviter-cancel-options';
 import type { SessionByeOptions } from 'sip.js/lib/api/session-bye-options';
 import type { InvitationAcceptOptions } from 'sip.js/lib/api/invitation-accept-options';
-
 import type { SessionDialog } from 'sip.js/lib/core/dialogs/session-dialog';
 import type { IncomingRequestMessage } from 'sip.js/lib/core/messages/incoming-request-message';
 import type { SessionDescriptionHandlerFactoryOptions } from 'sip.js/lib/platform/web/session-description-handler/session-description-handler-factory-options';
@@ -29,7 +28,7 @@ import { defaultPeerConnectionConfiguration } from 'sip.js/lib/platform/web/sess
 import getStats from 'getstats';
 
 import { OutgoingByeRequest, OutgoingInviteRequest, OutgoingRequest } from 'sip.js/lib/core';
-import { Inviter, Invitation, Registerer } from 'sip.js/lib/api';
+import { Inviter, Invitation, Registerer, Session } from 'sip.js/lib/api';
 import WazoSessionDescriptionHandler, { wazoMediaStreamFactory } from './lib/WazoSessionDescriptionHandler';
 import Emitter from './utils/Emitter';
 import ApiClient from './api-client';
@@ -37,6 +36,7 @@ import IssueReporter from './service/IssueReporter';
 import Heartbeat from './utils/Heartbeat';
 import { getVideoDirection, hasAnActiveVideo } from './utils/sdp';
 import { lastIndexOf } from './utils/array';
+import type { MediaConfig, UserAgentConfigOverrides, WebRtcConfig, UserAgentOptions } from './domain/types';
 
 // 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: Record<string, any>) => Promise.resolve({ // description is immutable... so we have to clone it or the `type` attribute won't be returned.
@@ -70,38 +70,17 @@ const ON_DISCONNECTED = 'onDisconnected';
 export const events = [REGISTERED, UNREGISTERED, REGISTRATION_FAILED, INVITE];
 export const transportEvents = [CONNECTED, DISCONNECTED, TRANSPORT_ERROR, MESSAGE];
 export class CanceledCallError extends Error {}
+
 const MAX_REGISTER_TRIES = 5;
-type MediaConfig = {
-  audio: Record<string, any> | boolean;
-  video?: Record<string, any> | boolean;
-  localVideo?: Record<string, any> | boolean;
-};
-type WebRtcConfig = {
-  displayName?: string;
-  host: string;
-  port?: number;
-  websocketSip?: string;
-  authorizationUser?: string;
-  password?: string;
-  uri?: string;
-  media?: MediaConfig;
-  iceCheckingTimeout?: number;
-  log?: Record<string, any>;
-  audioOutputDeviceId?: string;
-  audioOutputVolume?: number;
-  userAgentString?: string;
-  heartbeatDelay?: number;
-  heartbeatTimeout?: number;
-  maxHeartbeats?: number;
-  skipRegister?: boolean;
-}; // @see https://github.com/onsip/SIP.js/blob/master/src/Web/Simple.js
+// setting a 24hr timeout and letting the backend define the actual value
+const NO_ANSWER_TIMEOUT = 60 * 60 * 24; // in seconds
 
 export default class WebRTCClient extends Emitter {
   clientId: number;
 
   config: WebRtcConfig;
 
-  uaConfigOverrides: Record<string, any> | null | undefined;
+  uaConfigOverrides?: UserAgentConfigOverrides;
 
   userAgent: UserAgent | null;
 
@@ -201,7 +180,7 @@ export default class WebRTCClient extends Emitter {
     return [];
   }
 
-  constructor(config: WebRtcConfig, session: Invitation | Inviter | null | undefined, uaConfigOverrides: Record<string, any> | null | undefined = undefined) {
+  constructor(config: WebRtcConfig, session: Invitation | Inviter | null | undefined, uaConfigOverrides?: UserAgentConfigOverrides) {
     super();
 
     // For debug purpose
@@ -271,11 +250,11 @@ export default class WebRTCClient extends Emitter {
     this.audio = media.audio;
   }
 
-  createUserAgent(configOverrides: Record<string, any> | null | undefined): UserAgent {
-    const webRTCConfiguration = this._createWebRTCConfiguration(configOverrides);
+  createUserAgent(uaConfigOverrides?: UserAgentConfigOverrides): UserAgent {
+    const uaOptions = this._createUaOptions(uaConfigOverrides);
 
-    logger.info('sdk webrtc, creating UA', { webRTCConfiguration, clientId: this.clientId });
-    webRTCConfiguration.delegate = {
+    logger.info('sdk webrtc, creating UA', { uaOptions, clientId: this.clientId });
+    uaOptions.delegate = {
       onConnect: this.onConnect.bind(this),
       onDisconnect: this.onDisconnect.bind(this),
       onInvite: (invitation: Invitation) => {
@@ -293,7 +272,8 @@ export default class WebRTCClient extends Emitter {
         this.eventEmitter.emit(INVITE, invitation, this.sessionWantsToDoVideo(invitation), shouldAutoAnswer);
       },
     };
-    const ua: any = new UserAgent(webRTCConfiguration);
+    const ua: any = new UserAgent(uaOptions);
+    ua.start();
 
     if (ua.transport && ua.transport.connectPromise) {
       ua.transport.connectPromise.catch((e: any) => {
@@ -511,19 +491,32 @@ export default class WebRTCClient extends Emitter {
       registerer: !!this.registerer,
     });
 
-    if (!this.registerer) {
-      return Promise.resolve();
-    }
-
     try {
-      return this.registerer.unregister().then(() => {
-        logger.info('sdk webrtc unregistered', { clientId: this.clientId });
+      return new Promise((resolve, reject) => {
+        if (!this.registerer) {
+          return resolve();
+        }
+
+        const onRegisterStateChange = (state: string) => {
+          if (state === RegistererState.Unregistered) {
+            logger.info('sdk webrtc unregistered', { clientId: this.clientId });
+            if (this.registerer) {
+              this.registerer.stateChange.addListener(onRegisterStateChange);
+            }
+            this._cleanupRegister();
+
+            resolve();
+          }
+        };
 
-        this._cleanupRegister();
-      }).catch(e => {
-        logger.error('sdk webrtc unregistering, promise error', e);
+        this.registerer.stateChange.addListener(onRegisterStateChange);
 
-        this._cleanupRegister();
+        this.registerer.unregister().then().catch(e => {
+          logger.error('sdk webrtc unregistering, promise error', e);
+
+          this._cleanupRegister();
+          reject();
+        });
       });
     } catch (e: any) {
       logger.error('sdk webrtc unregistering, error', e);
@@ -593,9 +586,7 @@ export default class WebRTCClient extends Emitter {
     const inviteOptions: InviterInviteOptions = {
       requestDelegate: {
         onAccept: (response: IncomingResponse) => {
-          // @ts-ignore
           if (session.sessionDescriptionHandler?.peerConnection) {
-            // @ts-ignore
             session.sessionDescriptionHandler.peerConnection.sfu = conference;
           }
           // @ts-ignore
@@ -918,9 +909,9 @@ export default class WebRTCClient extends Emitter {
       isConference,
     };
 
-    if (isConference) {
-      this.mute(session);
-    }
+    // We should also mute the call, because when holding a call during a voicemail, the audio is still sent with the
+    // `sendonly` direction
+    this.mute(session);
 
     session.sessionDescriptionHandlerOptionsReInvite = {
       // @ts-ignore
@@ -968,9 +959,7 @@ export default class WebRTCClient extends Emitter {
       return Promise.resolve();
     }
 
-    if (isConference) {
-      this.unmute(session);
-    }
+    this.unmute(session);
 
     delete this.heldSessions[this.getSipSessionId(session)];
     session.sessionDescriptionHandlerOptionsReInvite = {
@@ -1395,9 +1384,9 @@ export default class WebRTCClient extends Emitter {
 
     // Release old video stream
     if (localStream) {
-      localStream.getVideoTracks().forEach(track => {
-        track.stop();
-      });
+      localStream.getVideoTracks()
+        .filter((track: MediaStreamTrack) => track.enabled)
+        .forEach((track: MediaStreamTrack) => track.stop());
     }
 
     const constraints = {
@@ -1799,7 +1788,7 @@ export default class WebRTCClient extends Emitter {
       return;
     }
 
-    remoteStream.getTracks().forEach(track => {
+    remoteStream.getVideoTracks().forEach(track => {
       remoteStream.removeTrack(track);
     });
 
@@ -1859,6 +1848,8 @@ export default class WebRTCClient extends Emitter {
     const audio: HTMLAudioElement = document.createElement('audio');
     audio.setAttribute('id', `audio-${sessionId}`);
 
+    logger.info('creating audio element', { sessionId, audioOutputDeviceId: this.audioOutputDeviceId });
+
     if ((audio as any).setSinkId && this.audioOutputDeviceId) {
       (audio as any).setSinkId(this.audioOutputDeviceId);
     }
@@ -2013,7 +2004,7 @@ export default class WebRTCClient extends Emitter {
     }));
   }
 
-  _createWebRTCConfiguration(configOverrides: Record<string, any> | null = {}): Record<string, any> {
+  _createUaOptions(uaOptionsOverrides: UserAgentConfigOverrides = {}): UserAgentOptions {
     let {
       host,
     } = this.config;
@@ -2024,12 +2015,13 @@ export default class WebRTCClient extends Emitter {
       [host] = webSocketSip;
       port = Number(webSocketSip[1]);
     }
+    const { userUuid } = this.config;
 
-    const config: Record<string, any> = {
+    const uaOptions: UserAgentOptions = {
+      noAnswerTimeout: NO_ANSWER_TIMEOUT,
       authorizationUsername: this.config.authorizationUser,
       authorizationPassword: this.config.password,
       displayName: this.config.displayName,
-      autoStart: true,
       hackIpInContact: true,
       contactParams: {
         transport: 'wss',
@@ -2041,7 +2033,8 @@ export default class WebRTCClient extends Emitter {
       userAgentString: this.config.userAgentString || 'wazo-sdk',
       reconnectionAttempts: 10000,
       reconnectionDelay: 5,
-      sessionDescriptionHandlerFactory: (session: Inviter | Invitation, options: SessionDescriptionHandlerFactoryOptions = {}) => {
+
+      sessionDescriptionHandlerFactory: (session: Session, options: SessionDescriptionHandlerFactoryOptions = {}) => {
         const uaLogger = session.userAgent.getLogger('sip.WazoSessionDescriptionHandler');
 
         const isWeb = this._isWeb();
@@ -2054,11 +2047,11 @@ export default class WebRTCClient extends Emitter {
             ...(options.peerConnectionConfiguration || {}),
           },
         };
-        return new WazoSessionDescriptionHandler(uaLogger, wazoMediaStreamFactory, sdhOptions, isWeb, session);
+        return new WazoSessionDescriptionHandler(uaLogger, wazoMediaStreamFactory, sdhOptions, isWeb, session as Inviter | Invitation);
       },
       transportOptions: {
-        traceSip: configOverrides?.traceSip || false,
-        wsServers: `wss://${host}:${port}/api/asterisk/ws`,
+        traceSip: uaOptionsOverrides?.traceSip || false,
+        wsServers: `wss://${host}:${port}/api/asterisk/ws${userUuid ? `?userUuid=${userUuid}` : ''}`,
       },
       sessionDescriptionHandlerFactoryOptions: {
         modifiers: [replaceLocalIpModifier],
@@ -2074,19 +2067,23 @@ export default class WebRTCClient extends Emitter {
             rtcpMuxPolicy: 'require',
             iceServers: WebRTCClient.getIceServers(this.config.host),
             ...this._getRtcOptions(),
-            ...(configOverrides?.peerConnectionOptions || {}),
+            ...(uaOptionsOverrides?.peerConnectionOptions || {}),
           },
         },
         // Configuration used in SDH to create the PeerConnection
         peerConnectionConfiguration: {
           rtcpMuxPolicy: 'require',
           iceServers: WebRTCClient.getIceServers(this.config.host),
-          ...(configOverrides?.peerConnectionOptions || {}),
+          ...(uaOptionsOverrides?.peerConnectionOptions || {}),
         },
       },
     };
-    return { ...config,
-      ...configOverrides,
+
+    delete uaOptionsOverrides?.traceSip;
+
+    return {
+      ...uaOptions,
+      ...uaOptionsOverrides,
     };
   }
 
@@ -2283,6 +2280,20 @@ export default class WebRTCClient extends Emitter {
     // @ts-ignore
     const earlyStream = sipSession && sipSession.sessionDescriptionHandler ? sipSession.sessionDescriptionHandler.remoteMediaStream : null;
     const stream = newStream || removeStream || earlyStream;
+    const shouldPause = audioElement.currentTime > 0 && !audioElement.paused && !audioElement.ended && audioElement.readyState > 2;
+
+    logger.info('setting up media', {
+      sessionId,
+      streams: {
+        new: !!newStream,
+        remove: !!removeStream,
+        early: !!earlyStream,
+      },
+      isWeb: this._isWeb(),
+      hasAudio: this._hasAudio(),
+      isConference,
+      shouldPause,
+    });
 
     if (!this._isWeb() || !stream) {
       return;
@@ -2293,7 +2304,7 @@ export default class WebRTCClient extends Emitter {
       return;
     }
 
-    if (audioElement.currentTime > 0 && !audioElement.paused && !audioElement.ended && audioElement.readyState > 2) {
+    if (shouldPause) {
       audioElement.pause();
     }
 
@@ -2337,7 +2348,7 @@ export default class WebRTCClient extends Emitter {
   }
 
   _cleanupStream(stream: MediaStream): void {
-    stream.getTracks().forEach(track => track.stop());
+    stream.getTracks().filter(track => track.enabled).forEach(track => track.stop());
   }
 
   _toggleAudio(session: Inviter | Invitation, muteAudio: boolean): void {
@@ -2594,8 +2605,11 @@ export default class WebRTCClient extends Emitter {
     networkStats.totalTransportReceived = transportReceived;
     networkStats.transportReceived = transportReceived - lastTransportReceived;
     networkStats.bandwidth = networkStats.audioBytesSent + networkStats.audioBytesReceived + networkStats.videoBytesSent + networkStats.videoBytesReceived + networkStats.transportReceived + networkStats.transportSent;
-    this.eventEmitter.emit(ON_NETWORK_STATS, session, networkStats, this.sessionNetworkStats[sessionId]);
-    this.sessionNetworkStats[sessionId].push(networkStats);
+
+    if (this.sessionNetworkStats[sessionId]) {
+      this.eventEmitter.emit(ON_NETWORK_STATS, session, networkStats, this.sessionNetworkStats[sessionId]);
+      this.sessionNetworkStats[sessionId].push(networkStats);
+    }
   }
 
   async _accept(session: Invitation, options: InvitationAcceptOptions = {}) {

package/src/websocket-client.ts

@@ -1,5 +1,7 @@
 /* eslint-disable no-underscore-dangle */
 import ReconnectingWebSocket from 'reconnecting-websocket';
+
+import Session from './domain/Session';
 import Emitter from './utils/Emitter';
 import type { WebSocketMessage } from './types/WebSocketMessage';
 import IssueReporter from './service/IssueReporter';
@@ -18,6 +20,7 @@ type Arguments = {
   token: string;
   events?: Array<string>;
   version?: number;
+  session?: Session,
   heartbeat?: {
     delay: number;
     timeout: number;
@@ -99,6 +102,8 @@ const messageLogger = IssueReporter.loggerFor('wazo-ws-message');
 class WebSocketClient extends Emitter {
   initialized: boolean;
 
+  session?: Session;
+
   host: string | null | undefined;
 
   version: number | undefined;
@@ -130,6 +135,7 @@ class WebSocketClient extends Emitter {
    * @param events
    * @param version
    * @param heartbeat
+   * @param session
    * @param options @see https://github.com/pladaria/reconnecting-websocket#available-options
    */
   constructor({
@@ -138,12 +144,14 @@ class WebSocketClient extends Emitter {
     version,
     events,
     heartbeat,
+    session,
   }: Arguments, options: Record<string, any> = {
     host,
     token,
     version: 1,
     events: [],
     heartbeat: {},
+    session: null,
   }) {
     super();
     this.initialized = false;
@@ -153,6 +161,7 @@ class WebSocketClient extends Emitter {
     this.events = events;
     this.options = options;
     this.version = version;
+    this.session = session;
     this._boundOnHeartbeat = this._onHeartbeat.bind(this);
     const {
       delay,
@@ -424,7 +433,11 @@ class WebSocketClient extends Emitter {
       this.close();
     }
 
-    const url = `wss://${this.host || ''}/api/websocketd/?token=${this.token || ''}&version=${this.version}`;
+    let url = `wss://${this.host || ''}/api/websocketd/?token=${this.token || ''}&version=${this.version}`;
+    if (this.session) {
+      url += `&userUuid=${this.session.uuid}`;
+    }
+
     logger.info('Wazo WS url computed to reconnect', {
       url,
     });