@wazo/sdk 1.0.0-alpha.1 → 1.0.0-alpha.11

package/src/voice/softphone.ts

@@ -10,21 +10,26 @@ import InvalidState from '../domain/InvalidState';
 
 import Wazo from '..';
 import softphoneStateMachine, { type SoftphoneActorRef, Actions, type StateTypes, States, ActionTypes } from '../state-machine/softphone-state-machine';
-import { Actions as CallActions } from '../state-machine/call-state-machine';
 import { WebRtcConfig, SipCall } from '../domain/types';
 import WazoWebRTCClient from '../web-rtc-client';
 import IssueReporter from '../service/IssueReporter';
 import configureLogger from '../utils/sip-logger';
 import Call from './call';
 import { assertCan, can, getState, waitUntilState } from '../state-machine/utils';
+import { getSipCallId } from '../utils/sdp';
 
 export const EVENT_INCOMING = 'incoming';
+export const EVENT_OUTGOING = 'outgoing';
 export const EVENT_HEARTBEAT = 'heartbeat';
 export const EVENT_HEARTBEAT_TIMEOUT = 'heartbeatTimeout';
 export const EVENT_REGISTERED = 'registered';
 export const EVENT_UNREGISTERED = 'unregistered';
 export const EVENT_DISCONNECTED = 'disconnected';
 export const EVENT_VIDEO_INPUT_CHANGE = 'videoInputChange';
+export const EVENT_TERMINATE_SOUND = 'terminateSound';
+export const EVENT_PLAY_HANGUP_SOUND = 'playHangupSound';
+export const EVENT_PLAY_RING_SOUND = 'playRingSound';
+export const EVENT_PLAY_INBOUND_CALL_SOUND = 'playInboundCallSound';
 export const EVENT_ON_MESSAGE = 'message';
 export const EVENT_ON_CHAT = 'phone/ON_CHAT';
 export const EVENT_ON_SIGNAL = 'phone/ON_SIGNAL';
@@ -40,6 +45,7 @@ export type CallOptions = {
   // If audioOnly is set to true, all video stream will be deactivated, even remotes ones.
   audioOnly?: boolean,
   conference?: boolean,
+  extraHeaders?: Record<string, any>,
 };
 
 const logger = IssueReporter.loggerFor('softphone');
@@ -53,8 +59,6 @@ export class Softphone extends EventEmitter {
 
   audioRingVolume: number;
 
-  eventEmitter: EventEmitter;
-
   calls: Call[];
 
   client: WazoWebRTCClient;
@@ -69,6 +73,8 @@ export class Softphone extends EventEmitter {
 
   shouldSendReinvite: boolean;
 
+  ringingEnabled = true;
+
   constructor() {
     super();
 
@@ -87,6 +93,8 @@ export class Softphone extends EventEmitter {
     const server = Wazo.Auth.getHost();
     const session = Wazo.Auth.getSession();
 
+    logger.info('softphone - connect', { server, session: !!session });
+
     if (!server || !session) {
       throw new Error('Please connect to the server using `Wazo.Auth.logIn` or `Wazo.Auth.authenticate` before using Room.connect().');
     }
@@ -103,14 +111,19 @@ export class Softphone extends EventEmitter {
     return this.connectWithCredentials(server, this.sipLine, session.displayName(), options);
   }
 
+  async hangupAllCalls() {
+    return Promise.all(this.calls.map(call => call.hangup()));
+  }
+
   async disconnect() {
     assertCan(this.softphoneActor, Actions.UNREGISTER);
     if (!this.client) {
+      logger.info('softphone - disconnect, not client to disconnect, bailing');
       return null;
     }
 
     // Terminate all calls
-    await Promise.all(this.calls.map(call => call.hangup()));
+    await this.hangupAllCalls();
 
     return this.client.unregister();
   }
@@ -127,7 +140,9 @@ export class Softphone extends EventEmitter {
   ): Promise<void> {
     assertCan(this.softphoneActor, Actions.REGISTER);
 
-    this.softphoneActor.send({ type: Actions.REGISTER });
+    logger.info('softphone - connect with credentials', { server, username: sipLine.username, displayName, options: rawOptions });
+
+    this._sendAction(Actions.REGISTER);
 
     const [host, port = 443] = server.split(':');
     let options = { ...rawOptions };
@@ -179,16 +194,16 @@ export class Softphone extends EventEmitter {
       return Promise.resolve(null);
     }
 
-    if (this.getState() !== States.UNREGISTERED) {
-      throw new InvalidState(`Invalid state ${States.UNREGISTERED}`, States.UNREGISTERED);
-    }
-
-    if (this.getState() !== States.REGISTERING) {
+    if (this.state === States.REGISTERING) {
       logger.info('softphone - calling when registering, waiting for Softphone to be registered ...');
 
       await waitUntilState(this.softphoneActor, States.REGISTERED);
     }
 
+    if (this.state !== States.REGISTERED) {
+      throw new InvalidState(`Invalid state ${States.UNREGISTERED}`, States.UNREGISTERED);
+    }
+
     // Hold other calls
     this.holdAllCalls();
 
@@ -197,6 +212,10 @@ export class Softphone extends EventEmitter {
     try {
       sipCall = this.client.call(options.params.To, options.withCamera, options.audioOnly, options.conference, options) as SipCall;
       const call = new Call(sipCall, this);
+      call.onMakeCall();
+
+      this.calls.push(call);
+      this.emit(EVENT_OUTGOING, call);
 
       return call;
     } catch (error: any) {
@@ -209,12 +228,77 @@ export class Softphone extends EventEmitter {
     this.calls = this.calls.filter((call: Call) => call.id !== callToRemove.id);
   }
 
+  onCallTerminated(call: Call) {
+    logger.info('softphone - on call terminated', { id: call.id });
+
+    const currentCall = this.getCurrentCall();
+    const isCurrentCall = currentCall?.id === call.id;
+    const isRinging = call.isRinging();
+    const isCurrentIncomingCall = isCurrentCall && isRinging;
+    const incomingCalls = this.getIncomingCalls();
+    const nbIncomingCalls = incomingCalls.length;
+
+    // Send an event to terminate ringing sound
+    if (isCurrentIncomingCall) {
+      setTimeout(() => {
+        // Avoid race condition when the other is calling and hanging up immediately
+        this.emit(EVENT_TERMINATE_SOUND, call, 'call terminated');
+      }, 5);
+    }
+
+    // If the terminated call was an incoming call, we have to re-trigger if it's was the first incoming call
+    // Otherwise, we have to re-trigger an incoming call event if another call is incoming
+    const shouldRetrigger = isCurrentCall ? nbIncomingCalls : isCurrentIncomingCall;
+
+    // Re-trigger incoming call event for remaining incoming calls
+    logger.info('Softphone - check to re-trigger incoming call', { shouldRetrigger, nbIncomingCalls });
+
+    if (shouldRetrigger && nbIncomingCalls > 1) {
+      const nextCall = incomingCalls.find(c => c.id !== call.id);
+      // Avoid race condition
+      setTimeout(() => {
+        if (this.ringingEnabled) {
+          if (currentCall) {
+            this.emit(EVENT_PLAY_RING_SOUND, this.audioRingDeviceId, this.audioRingVolume, nextCall);
+          } else {
+            this.emit(EVENT_PLAY_INBOUND_CALL_SOUND, this.audioOutputDeviceId, this.audioOutputVolume, nextCall);
+          }
+        }
+
+        this.emit(EVENT_INCOMING, nextCall);
+      }, 100);
+    }
+
+    // @ts-ignore: does not exist
+    if (!call.sipCall.isCanceled) {
+      setTimeout(() => {
+        this.emit(EVENT_PLAY_HANGUP_SOUND, this.audioOutputDeviceId, this.audioOutputVolume, call);
+      }, 10);
+    }
+
+    this.client.onCallEnded(call.sipCall);
+
+    this.removeCall(call);
+  }
+
+  enableRinging(): Promise<void> | void {
+    logger.info('softphone - enable ringing');
+    this.ringingEnabled = true;
+  }
+
+  disableRinging(): Promise<void> | void {
+    logger.info('softphone - disable ringing');
+    this.ringingEnabled = false;
+  }
+
   holdAllCalls(exceptCall: Call | null = null) {
-    this.calls.filter(call => !call.isHeld() && call.id === exceptCall?.id).forEach(call => call.hold());
+    logger.info('softphone - hold all calls', { exceptId: exceptCall?.id, ids: this.calls.map(call => call.id) });
+
+    this.calls.filter(call => !call.isHeld() && call.id !== exceptCall?.id).forEach(call => call.hold());
   }
 
   startHeartbeat() {
-    logger.info('softphone - start heartbeat', { client: !!this.client, hasHeartbeat: this.client.hasHeartbeat() });
+    logger.info('softphone - start heartbeat', { client: !!this.client, hasHeartbeat: this.client?.hasHeartbeat() });
     if (!this.client || this.client.hasHeartbeat()) {
       return;
     }
@@ -278,34 +362,64 @@ export class Softphone extends EventEmitter {
     this.audioRingVolume = volume;
   }
 
-  getCalls(): Call[] {
-    return this.calls;
+  getCurrentCall(): Call | undefined {
+    return this.getActiveCalls()[0];
   }
 
-  getCurrentCall(): Call | undefined {
-    return this.calls.find(call => call.isEstablished());
+  getActiveCalls(): Call[] {
+    return this.calls.filter(call => call.isEstablished());
+  }
+
+  getIncomingCalls(): Call[] {
+    return this.calls.filter(call => call.isRinging());
+  }
+
+  get state(): StateTypes {
+    return getState(this.softphoneActor) as StateTypes;
   }
 
-  getState(): StateTypes {
-    return this.softphoneActor.getSnapshot().value;
+  get user() {
+    return this.client?.userAgent?.contact?.uri?.user;
   }
 
   getUserAgent() {
     return this.client?.config?.userAgentString || 'softphone';
   }
 
+  isRegistering() {
+    return this.state === States.REGISTERING;
+  }
+
+  isRegistered() {
+    return this.state === States.REGISTERED;
+  }
+
+  isUnRegistered() {
+    return this.state === States.UNREGISTERED;
+  }
+
   _bindEvents(): void {
     this.client.on(this.client.INVITE, (sipSession: SipCall) => {
       const call = new Call(sipSession, this);
-      call._sendAction(CallActions.INCOMING_CALL);
+      logger.info('softphone - on invite', { callId: call.id, number: call.number });
+
+      call.onCallIncoming();
       this.calls.push(call);
 
-      this.eventEmitter.emit(EVENT_INCOMING, call);
+      this.emit(EVENT_INCOMING, call);
+
+      if (!this.getCurrentCall()) {
+        if (this.ringingEnabled) {
+          this.emit(EVENT_PLAY_RING_SOUND, this.audioRingDeviceId, this.audioRingVolume, call);
+        }
+      } else {
+        this.emit(EVENT_PLAY_INBOUND_CALL_SOUND, this.audioOutputDeviceId, this.audioOutputVolume, call);
+      }
     });
 
     this.client.on(this.client.ON_REINVITE, (sipCall: SipCall, request: IncomingRequestMessage, updatedCalleeName: string, updatedNumber: string, hadRemoteVideo: boolean) => {
       logger.info('softphone - on reinvite', {
-        callId: sipCall.id,
+        callId: getSipCallId(sipCall),
         inviteId: request.callId,
         updatedCalleeName,
         updatedNumber,
@@ -316,6 +430,9 @@ export class Softphone extends EventEmitter {
     });
 
     this.client.on(this.client.ACCEPTED, async (sipCall: SipCall) => {
+      const call = this._getCall(sipCall);
+      this.emit(EVENT_TERMINATE_SOUND, call, 'call accepted');
+
       this._onCallEvent(sipCall, 'onAccepted');
 
       if (this.audioOutputDeviceId) {
@@ -354,29 +471,39 @@ export class Softphone extends EventEmitter {
 
     this.client.on(this.client.UNREGISTERED, () => {
       logger.info('softphone - unregistered');
-      this.eventEmitter.emit(EVENT_UNREGISTERED);
+      if (!can(this.softphoneActor, Actions.UNREGISTER)) {
+        logger.warn('softphone - cannot unregister', { state: this.state });
+        return;
+      }
 
-      this._sendAction(Actions.UNREGISTERED);
+      this._sendAction(Actions.UNREGISTER);
+
+      this.emit(EVENT_UNREGISTERED);
     });
 
     this.client.on(this.client.ON_DISCONNECTED, () => {
       logger.info('softphone - disconnected');
-      this.eventEmitter.emit(EVENT_DISCONNECTED);
+      if (!can(this.softphoneActor, Actions.TRANSPORT_CLOSED)) {
+        logger.warn('softphone - cannot disconnected', { state: this.state });
+        return;
+      }
 
       this._sendAction(Actions.TRANSPORT_CLOSED);
+
+      this.emit(EVENT_DISCONNECTED);
     });
 
     this.client.on(this.client.REGISTERED, () => {
       logger.info('softphone - registered', { state: getState(this.softphoneActor) });
       if (!can(this.softphoneActor, Actions.REGISTER_DONE)) {
-        logger.warn('softphone - registered but not in REGISTERING state', { state: getState(this.softphoneActor) });
+        logger.warn('softphone - registered but not in REGISTERING state', { state: this.state });
         return;
       }
 
       this.stopHeartbeat();
       this._sendAction(Actions.REGISTER_DONE);
 
-      this.eventEmitter.emit(EVENT_REGISTERED);
+      this.emit(EVENT_REGISTERED);
 
       // If the phone registered with a current callSession (eg: when switching network):
       // send a reinvite to renegociate ICE with new IP
@@ -390,13 +517,19 @@ export class Softphone extends EventEmitter {
     });
 
     this.client.on(this.client.CONNECTED, () => {
-      logger.info('softphone - connected');
+      logger.info('softphone - connected', { state: this.state });
       this.stopHeartbeat();
     });
 
+    this.client.on(this.client.REGISTERING, () => {
+      logger.info('softphone - registering', { state: this.state });
+
+      this._sendAction(Actions.REGISTER);
+    });
+
     this.client.on(this.client.DISCONNECTED, () => {
       logger.info('softphone - disconnected');
-      this.eventEmitter.emit(EVENT_DISCONNECTED);
+      this.emit(EVENT_DISCONNECTED);
 
       // Do not trigger heartbeat if already running
       if (!this.client.hasHeartbeat()) {
@@ -408,38 +541,44 @@ export class Softphone extends EventEmitter {
     });
 
     this.client.on('onVideoInputChange', stream => {
-      this.eventEmitter.emit(EVENT_VIDEO_INPUT_CHANGE, stream);
+      this.emit(EVENT_VIDEO_INPUT_CHANGE, stream);
     });
 
     this.client.on(this.client.MESSAGE, (message: Message) => {
       this._onMessage(message);
 
-      this.eventEmitter.emit(EVENT_ON_MESSAGE, message);
+      this.emit(EVENT_ON_MESSAGE, message);
     });
 
     this.client.setOnHeartbeatTimeout(() => {
-      this.eventEmitter.emit(EVENT_HEARTBEAT_TIMEOUT);
+      this.emit(EVENT_HEARTBEAT_TIMEOUT);
     });
 
     this.client.setOnHeartbeatCallback(() => {
-      this.eventEmitter.emit(EVENT_HEARTBEAT);
+      this.emit(EVENT_HEARTBEAT);
     });
   }
 
-  _sendAction(action: ActionTypes) {
+  private _sendAction(action: ActionTypes) {
+    const was = this.state;
     this.softphoneActor.send({ type: action });
+    logger.trace('softphone - send action', { action, was, state: this.state });
+  }
+
+  private _getCall(sipCall: SipCall): Call | undefined {
+    return this.calls.find(call => call.id === getSipCallId(sipCall));
   }
 
-  _getCall(sipCall: SipCall): Call | undefined {
-    return this.calls.find(call => call.id === sipCall.id);
+  private _getCallIds(): string[] {
+    return this.calls.map(call => call.id);
   }
 
-  _onCallEvent(sipCall: SipCall, eventName: string, ...args: any[]) {
-    logger.warn('softphone - received call event', { eventName, sipId: sipCall.id });
+  private _onCallEvent(sipCall: SipCall, eventName: string, ...args: any[]) {
+    logger.info('softphone - received call event', { eventName, sipId: getSipCallId(sipCall) });
 
     const call = this._getCall(sipCall);
     if (!call) {
-      logger.warn('softphone - no call found to send the event', { eventName, sipId: sipCall.id });
+      logger.warn('softphone - no call found to send the event', { eventName, sipId: getSipCallId(sipCall), ids: this._getCallIds() });
       return;
     }
 
@@ -447,7 +586,7 @@ export class Softphone extends EventEmitter {
     call[eventName](...args);
   }
 
-  _onMessage(message: Message & { method?: string, body?: string }): void {
+  private _onMessage(message: Message & { method?: string, body?: string }): void {
     if (!message || message.method !== 'MESSAGE') {
       return;
     }
@@ -467,12 +606,12 @@ export class Softphone extends EventEmitter {
 
     switch (type) {
       case MESSAGE_TYPE_CHAT:
-        this.eventEmitter.emit(EVENT_ON_CHAT, content);
+        this.emit(EVENT_ON_CHAT, content);
         break;
 
       case MESSAGE_TYPE_SIGNAL:
       {
-        this.eventEmitter.emit(EVENT_ON_SIGNAL, content);
+        this.emit(EVENT_ON_SIGNAL, content);
         break;
       }