@wazo/sdk 1.0.0-alpha.2 → 1.0.0-alpha.20

package/src/voice/call.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-underscore-dangle */
 import { EventEmitter } from 'events';
 import { createActor } from 'xstate';
+import { Inviter } from 'sip.js/lib/api/inviter';
 import { Invitation } from 'sip.js/lib/api/invitation';
 import { SessionState } from 'sip.js/lib/api/session-state';
 import { OutgoingInviteRequest } from 'sip.js/lib/core';
@@ -8,15 +9,16 @@ import { SessionDescriptionHandler } from 'sip.js/lib/platform/web';
 import { SessionDescriptionHandlerOptions } from 'sip.js/lib/api';
 import type { IncomingRequestMessage } from 'sip.js/lib/core/messages/incoming-request-message';
 
-import callStateMachine, { type ActionTypes, Actions, type EstablishedActionTypes, EstablishedActions, States, type StateTypes, EstablishedStates, type EstablishedStateTypes, type CallActorRef } from '../state-machine/call-state-machine';
+import callStateMachine, { type ActionTypes, Actions, type EstablishedActionTypes, EstablishedActions, States, type StateTypes, EstablishedStates, type EstablishedStateTypes, type CallActorRef, EstablishedSubStateTypes } from '../state-machine/call-state-machine';
 import { SipCall, PeerConnection } from '../domain/types';
 import ApiCall from '../domain/Call';
-
+import newFrom from '../utils/new-from';
+import updateFrom from '../utils/update-from';
 import IssueReporter from '../service/IssueReporter';
-import softphone, { EVENT_TERMINATE_SOUND, Softphone } from './softphone';
-import { getCallDisplayName, getCallNumber, getSipSessionId } from '../utils/sdp';
+import softphone, { Softphone } from './softphone';
+import { getCallDisplayName, getCallNumber, getSipCallId } from '../utils/sdp';
 import { assertCan, assertState, getState } from '../state-machine/utils';
-import { downgradeToAudio, getLocalStream, getLocalVideoStream, getPeerConnection, getRemoteStream, getRemoteVideoStream, getStreamFromConstraints, getWebRtcStats, hasALocalVideoTrack, hasLocalVideo, hasRemoteVideo, isVideoMuted, isVideoRemotelyHeld, setLocalMediaStream, toggleVideo, upgradeToVideo } from '../utils/webrtc';
+import { downgradeToAudio, getLocalStream, getLocalVideoStream, getPeerConnection, getRemoteStream, getRemoteVideoStream, getStreamFromConstraints, getWebRtcStats, hasALocalVideoTrack, hasLocalVideo, hasRemoteVideo, isVideoMuted, isVideoRemotelyHeld, sessionWantsToDoVideo, setLocalMediaStream, toggleVideo, upgradeToVideo } from '../utils/webrtc';
 
 const logger = IssueReporter.loggerFor('call');
 
@@ -32,7 +34,8 @@ export type ReinviteOptions = {
 };
 
 // Events
-export const EVENT_CALL_ACCEPTED = 'accepted';
+export const EVENT_CALL_REMOTLY_ACCEPTED = 'remotelyAccepted';
+export const EVENT_CALL_LOCALLY_ACCEPTED = 'locallyAccepted';
 export const EVENT_CALL_CANCELED = 'canceled';
 export const EVENT_PROGRESS = 'progress';
 export const EVENT_EARLY_MEDIA = 'earlyMedia';
@@ -60,6 +63,8 @@ export const MESSAGE_TYPE_CHAT = 'message/TYPE_CHAT';
 export const MESSAGE_TYPE_SIGNAL = 'message/TYPE_SIGNAL';
 export const MESSAGE_TRACK_UPDATED = 'onTrackUpdated';
 
+const attributesToUpdate = ['apiId', 'talkingToIds', 'creationTime', 'answerTime', 'endTime', 'recording', 'recordingPaused', 'displayName', 'number'];
+
 class Call extends EventEmitter {
   callActor: CallActorRef;
 
@@ -72,7 +77,7 @@ class Call extends EventEmitter {
 
   creationTime: Date;
 
-  answerTime: Date;
+  answerTime: Date | null;
 
   endTime: Date;
 
@@ -82,12 +87,18 @@ class Call extends EventEmitter {
 
   recording = false;
 
+  recordingPaused = false;
+
   displayName: string | null;
 
   number: string | null;
 
   currentScreenShare: Record<string, any> | null;
 
+  static newFrom(call: Call) {
+    return newFrom(call, Call);
+  }
+
   static parseCall(apiCall: ApiCall): Call {
     const sipCall = {
       id: apiCall.sipCallId,
@@ -97,32 +108,44 @@ class Call extends EventEmitter {
       remoteIdentity: {
         uri: {
           _normal: {
-            user: apiCall.calleeNumber,
+            user: apiCall.calleeName || apiCall.calleeNumber,
           },
         },
       },
       // Mock sdk so `hasLocalVideo` will return true.
       sessionDescriptionHandler: {
         localMediaStream: {
-          getTracks: () => (apiCall.isVideo ? [{ kind: 'video', readyState: 'live' }] : []),
+          getTracks: () => (apiCall.isVideo ? [{ id: 'mocked', kind: 'video', readyState: 'live' }] : []),
         },
       },
     } as any;
 
     const call = new Call(sipCall, softphone);
-    // call._sendAction(Actions.ES);
     call.apiId = apiCall.id;
-    call.answerTime = new Date(+apiCall.startingTime);
+    call.creationTime = new Date(+apiCall.startingTime);
+    call.recording = apiCall.isRecording();
 
     // Update call state
     const snapshot = call.callActor.getSnapshot();
 
     if (apiCall.isUp()) {
-      snapshot.value = { [States.ESTABLISHED]: EstablishedStates.ONGOING };
+      snapshot.value = {
+        [States.ESTABLISHED]: {
+          [EstablishedStates.ONGOING]: {},
+          muteState: EstablishedStates.UN_MUTED,
+          holdState: EstablishedStates.UN_HELD,
+        },
+      };
     }
 
     if (apiCall.muted) {
-      snapshot.value = { [States.ESTABLISHED]: EstablishedStates.MUTED };
+      snapshot.value = {
+        [States.ESTABLISHED]: {
+          [EstablishedStates.ONGOING]: {},
+          muteState: EstablishedStates.MUTED,
+          holdState: EstablishedStates.UN_HELD,
+        },
+      };
     }
 
     if (apiCall.isRinging()) {
@@ -152,8 +175,6 @@ class Call extends EventEmitter {
 
     this.number = getCallNumber(sipCall);
     this.displayName = getCallDisplayName(sipCall);
-
-    this._bindEvents();
   }
 
   async accept(options: AcceptOptions = {}): Promise<string | null> {
@@ -170,6 +191,8 @@ class Call extends EventEmitter {
     return this.phone.client.answer(this.sipCall as Invitation, options.withCamera).then(() => {
       logger.info('call - accepted', { id: this.id, ...options });
 
+      this.emit(EVENT_CALL_LOCALLY_ACCEPTED, this);
+
       return this.id;
     }).catch(e => {
       logger.error(e);
@@ -182,19 +205,21 @@ class Call extends EventEmitter {
     assertCan(this.callActor, Actions.REJECT);
     logger.info('call - reject', { id: this.id });
 
-    this.phone.emit(EVENT_TERMINATE_SOUND, 'call rejected locally');
-
-    this.shouldSendReinvite = false;
-
-    return this.hangup();
+    return this._terminate();
   }
 
   async hangup(): Promise<boolean> {
     assertCan(this.callActor, Actions.HANGUP);
     logger.info('call - hangup', { id: this.id });
 
+    return this._terminate();
+  }
+
+  async _terminate(): Promise<boolean> {
     await this.phone.client.hangup(this.sipCall);
 
+    this.shouldSendReinvite = false;
+
     // Remove this call from softphone's calls
     this.phone.onCallTerminated(this);
 
@@ -318,7 +343,7 @@ class Call extends EventEmitter {
   turnCameraOn(): void {
     assertState(this.callActor, States.ESTABLISHED);
     logger.info('call - turn camera on', { id: this.id });
-    toggleVideo(this.sipCall, true);
+    toggleVideo(this.sipCall, false);
 
     this.emit(EVENT_CAMERA_RESUMED);
   }
@@ -326,13 +351,13 @@ class Call extends EventEmitter {
   turnCameraOff(): void {
     assertState(this.callActor, States.ESTABLISHED);
     logger.info('call -  turn camera off', { id: this.id });
-    toggleVideo(this.sipCall, false);
+    toggleVideo(this.sipCall, true);
 
     this.emit(EVENT_CAMERA_DISABLED);
   }
 
   isMuted() {
-    return this._hasEstablishedState(EstablishedStates.MUTED);
+    return this._hasEstablishedState('muteState', EstablishedStates.MUTED);
   }
 
   isCameraMuted() {
@@ -340,11 +365,27 @@ class Call extends EventEmitter {
   }
 
   isHeld() {
-    return this._hasEstablishedState(EstablishedStates.HELD);
+    return this._hasEstablishedState('holdState', EstablishedStates.HELD);
+  }
+
+  isEstablishing() {
+    return this.sipCall.state === SessionState.Establishing;
   }
 
   isEstablished() {
-    return States.ESTABLISHED in (this.state as Record<StateTypes, EstablishedStateTypes>);
+    return typeof this.state === 'object' && States.ESTABLISHED in (this.state as Record<StateTypes, EstablishedStateTypes>);
+  }
+
+  isRinging() {
+    return this.state === States.RINGING;
+  }
+
+  isOutgoing() {
+    return this.sipCall instanceof Inviter;
+  }
+
+  isIncoming() {
+    return !this.isOutgoing();
   }
 
   isConference(): boolean {
@@ -355,7 +396,7 @@ class Call extends EventEmitter {
     assertState(this.callActor, States.ESTABLISHED);
     logger.info('call - transfer', { id: this.id, target });
 
-    this.phone.client.transfer(this.sipCall, target);
+    return this.phone.client.transfer(this.sipCall, target);
   }
 
   atxfer(): Record<string, any> | null | undefined {
@@ -526,9 +567,17 @@ class Call extends EventEmitter {
     this._onScreenSharing(localStream as MediaStream, false, desktop);
   }
 
+  onMakeCall() {
+    this._bindEvents();
+
+    this._sendAction(Actions.MAKE_CALL);
+  }
+
   onAccepted() {
+    this.answerTime = new Date();
+
     this._sendAction(Actions.REMOTLY_ACCEPTED);
-    this.emit(EVENT_CALL_ACCEPTED);
+    this.emit(EVENT_CALL_REMOTLY_ACCEPTED);
   }
 
   onProgress() {
@@ -549,6 +598,8 @@ class Call extends EventEmitter {
 
   onCallIncoming() {
     this._sendAction(Actions.INCOMING_CALL);
+
+    this._bindEvents();
   }
 
   onRejected() {
@@ -579,6 +630,10 @@ class Call extends EventEmitter {
     return hasLocalVideo(this.sipCall);
   }
 
+  wantsToDoVideo() {
+    return sessionWantsToDoVideo(this.sipCall);
+  }
+
   getLocalStream() {
     return getLocalStream(this.sipCall);
   }
@@ -595,25 +650,41 @@ class Call extends EventEmitter {
     return isVideoRemotelyHeld(this.sipCall);
   }
 
-  isRinging() {
-    return this.state === States.RINGING;
-  }
-
   onReinvite(request: IncomingRequestMessage, updatedCalleeName: string, updatedNumber: string, hadRemoteVideo: boolean) {
     this.emit(EVENT_REINVITE, request, updatedCalleeName, updatedNumber, hadRemoteVideo);
   }
 
+  updateFrom(call: Call) {
+    updateFrom(this, call, attributesToUpdate);
+  }
+
+  is(otherCall: Call) {
+    return otherCall && this.id && this.id === otherCall.id;
+  }
+
+  shouldAutoAnswer() {
+    return !!this.sipCall.request?.getHeader('alert-info');
+  }
+
   get id() {
-    return getSipSessionId(this.sipCall);
+    return getSipCallId(this.sipCall);
   }
 
   get state(): StateTypes | Record<StateTypes, EstablishedStateTypes> {
     return getState(this.callActor) as StateTypes | Record<StateTypes, EstablishedStateTypes>;
   }
 
-  private _hasEstablishedState(establishedState: EstablishedStateTypes) {
-    const state = this.state as Record<StateTypes, EstablishedStateTypes>;
-    return States.ESTABLISHED in state && state[States.ESTABLISHED] === establishedState;
+  private _hasEstablishedState(subState: EstablishedSubStateTypes, establishedState: EstablishedStateTypes) {
+    const state = this.state as Record<StateTypes, EstablishedStateTypes | Record<EstablishedSubStateTypes, EstablishedStateTypes>>;
+    if (typeof state !== 'object') {
+      return false;
+    }
+
+    if (!(States.ESTABLISHED in state)) {
+      return false;
+    }
+
+    return (state[States.ESTABLISHED] as Record<EstablishedSubStateTypes, EstablishedStateTypes>)[subState] === establishedState;
   }
 
   private _bindEvents() {
@@ -630,7 +701,7 @@ class Call extends EventEmitter {
       };
     }
 
-    this.sipCall.stateChange.addListener((newState: SessionState) => {
+    this.sipCall?.stateChange?.addListener((newState: SessionState) => {
       switch (newState) {
         case SessionState.Terminating:
           logger.info('call - terminating', { id: this.id });
@@ -784,7 +855,9 @@ class Call extends EventEmitter {
   }
 
   private _sendAction(action: ActionTypes | EstablishedActionTypes) {
+    const was = this.state;
     this.callActor.send({ type: action });
+    logger.trace('call - send action', { id: this.id, action, was, state: this.state });
   }
 }
 

package/src/voice/softphone.ts

@@ -16,6 +16,7 @@ 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';
@@ -44,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');
@@ -91,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().');
     }
@@ -107,16 +111,25 @@ 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);
+    logger.info('softphone - disconnect');
+
     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();
+    await this.client.unregister();
+
+    return this.client.close();
   }
 
   getPrimaryWebRtcLine(): SipLine | null {
@@ -131,7 +144,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 };
@@ -171,7 +186,7 @@ export class Softphone extends EventEmitter {
       return;
     }
 
-    this.client.attemptReconnection();
+    this.client.register();
   }
 
   async call(options: CallOptions): Promise<Call | null> {
@@ -189,7 +204,7 @@ export class Softphone extends EventEmitter {
       await waitUntilState(this.softphoneActor, States.REGISTERED);
     }
 
-    if (this.state !== States.UNREGISTERED) {
+    if (this.state !== States.REGISTERED) {
       throw new InvalidState(`Invalid state ${States.UNREGISTERED}`, States.UNREGISTERED);
     }
 
@@ -201,7 +216,9 @@ 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;
@@ -279,11 +296,13 @@ export class Softphone extends EventEmitter {
   }
 
   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;
     }
@@ -348,7 +367,11 @@ export class Softphone extends EventEmitter {
   }
 
   getCurrentCall(): Call | undefined {
-    return this.calls.find(call => call.isEstablished());
+    return this.getActiveCalls()[0];
+  }
+
+  getActiveCalls(): Call[] {
+    return this.calls.filter(call => call.isEstablished());
   }
 
   getIncomingCalls(): Call[] {
@@ -359,14 +382,26 @@ export class Softphone extends EventEmitter {
     return getState(this.softphoneActor) as StateTypes;
   }
 
+  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);
@@ -388,7 +423,7 @@ export class Softphone extends EventEmitter {
 
     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,
@@ -440,22 +475,32 @@ export class Softphone extends EventEmitter {
 
     this.client.on(this.client.UNREGISTERED, () => {
       logger.info('softphone - unregistered');
-      this.emit(EVENT_UNREGISTERED);
+      if (!can(this.softphoneActor, Actions.UNREGISTER)) {
+        logger.warn('softphone - cannot unregister', { state: this.state });
+        return;
+      }
+
+      this._sendAction(Actions.UNREGISTER);
 
-      this._sendAction(Actions.UNREGISTERED);
+      this.emit(EVENT_UNREGISTERED);
     });
 
     this.client.on(this.client.ON_DISCONNECTED, () => {
       logger.info('softphone - disconnected');
-      this.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) });
+      logger.info('softphone - registered', { state: getState(this.softphoneActor), reinvite: this.shouldSendReinvite });
       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;
       }
 
@@ -476,10 +521,16 @@ 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.emit(EVENT_DISCONNECTED);
@@ -513,19 +564,25 @@ export class Softphone extends EventEmitter {
   }
 
   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 === sipCall.id);
+    return this.calls.find(call => call.id === getSipCallId(sipCall));
+  }
+
+  private _getCallIds(): string[] {
+    return this.calls.map(call => call.id);
   }
 
   private _onCallEvent(sipCall: SipCall, eventName: string, ...args: any[]) {
-    logger.warn('softphone - received call event', { eventName, sipId: sipCall.id });
+    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;
     }