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

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,13 +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, EstablishedStates, type CallActorRef } from '../state-machine/call-state-machine';
+import callStateMachine, { type ActionTypes, Actions, type EstablishedActionTypes, EstablishedActions, States, type StateTypes, EstablishedStates, type EstablishedStateTypes, type CallActorRef } 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 } from './softphone';
-import { 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, isVideoRemotelyHeld, setLocalMediaStream, toggleVideo, upgradeToVideo } from '../utils/webrtc';
+import { downgradeToAudio, getLocalStream, getLocalVideoStream, getPeerConnection, getRemoteStream, getRemoteVideoStream, getStreamFromConstraints, getWebRtcStats, hasALocalVideoTrack, hasLocalVideo, hasRemoteVideo, isVideoMuted, isVideoRemotelyHeld, setLocalMediaStream, toggleVideo, upgradeToVideo } from '../utils/webrtc';
 
 const logger = IssueReporter.loggerFor('call');
 
@@ -30,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';
@@ -53,15 +58,12 @@ export const EVENT_SHARE_SCREEN_ENDED = 'onScreenShareEnded';
 export const EVENT_WEB_RTC_STATS = 'webRtcStats';
 export const EVENT_CAMERA_RESUMED = 'onCameraResumed';
 export const EVENT_CAMERA_DISABLED = 'onCameraDisabled';
-export const EVENT_TERMINATE_SOUND = 'terminateSound';
 
 export const MESSAGE_TYPE_CHAT = 'message/TYPE_CHAT';
 export const MESSAGE_TYPE_SIGNAL = 'message/TYPE_SIGNAL';
 export const MESSAGE_TRACK_UPDATED = 'onTrackUpdated';
 
 class Call extends EventEmitter {
-  eventEmitter: EventEmitter;
-
   callActor: CallActorRef;
 
   // Wazo call id, used in Wazo Websocket and API
@@ -81,8 +83,68 @@ class Call extends EventEmitter {
 
   shouldSendReinvite = false;
 
+  recording = 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,
+      stateChange: {
+        addListener: () => {},
+      },
+      remoteIdentity: {
+        uri: {
+          _normal: {
+            user: apiCall.calleeNumber,
+          },
+        },
+      },
+      // Mock sdk so `hasLocalVideo` will return true.
+      sessionDescriptionHandler: {
+        localMediaStream: {
+          getTracks: () => (apiCall.isVideo ? [{ kind: 'video', readyState: 'live' }] : []),
+        },
+      },
+    } as any;
+
+    const call = new Call(sipCall, softphone);
+    call.apiId = apiCall.id;
+    call.answerTime = new Date(+apiCall.startingTime);
+
+    // Update call state
+    const snapshot = call.callActor.getSnapshot();
+
+    if (apiCall.isUp()) {
+      snapshot.value = { [States.ESTABLISHED]: EstablishedStates.ONGOING };
+    }
+
+    if (apiCall.muted) {
+      snapshot.value = { [States.ESTABLISHED]: EstablishedStates.MUTED };
+    }
+
+    if (apiCall.isRinging()) {
+      snapshot.value = States.RINGING;
+    }
+
+    if (apiCall.isRecording()) {
+      call.recording = true;
+    }
+
+    // @ts-ignore
+    call.callActor.update(snapshot);
+
+    return call;
+  }
+
   constructor(sipCall: SipCall, phone: Softphone) {
     super();
 
@@ -94,7 +156,8 @@ class Call extends EventEmitter {
     this.phone = phone;
     this.sipCall = sipCall;
 
-    this._bindEvents();
+    this.number = getCallNumber(sipCall);
+    this.displayName = getCallDisplayName(sipCall);
   }
 
   async accept(options: AcceptOptions = {}): Promise<string | null> {
@@ -111,6 +174,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);
@@ -123,21 +188,23 @@ class Call extends EventEmitter {
     assertCan(this.callActor, Actions.REJECT);
     logger.info('call - reject', { id: this.id });
 
-    this.eventEmitter.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.removeCall(this);
+    this.phone.onCallTerminated(this);
 
     return true;
   }
@@ -151,7 +218,7 @@ class Call extends EventEmitter {
     }
   }
 
-  startConference(withCalls: Call[]) {
+  startConference(/* withCalls: Call[] */) {
     // @TODO
     // const participants = [this, ...withCalls].reduce((acc: Record<string, any>, call: Call) => {
     //   acc[call.talkingToIds[0]] = call;
@@ -174,7 +241,7 @@ class Call extends EventEmitter {
 
     this.phone.client.mute(this.sipCall);
 
-    this.eventEmitter.emit(EVENT_CALL_MUTED);
+    this.emit(EVENT_CALL_MUTED);
   }
 
   unMute() {
@@ -185,7 +252,7 @@ class Call extends EventEmitter {
 
     this.phone.client.unmute(this.sipCall);
 
-    this.eventEmitter.emit(EVENT_CALL_UN_MUTED);
+    this.emit(EVENT_CALL_UN_MUTED);
   }
 
   async hold() {
@@ -208,7 +275,7 @@ class Call extends EventEmitter {
 
     const promise = this.phone.client.hold(this.sipCall, this.isConference(), hasVideo);
 
-    this.eventEmitter.emit(EVENT_CALL_HELD);
+    this.emit(EVENT_CALL_HELD);
 
     return promise;
   }
@@ -244,7 +311,7 @@ class Call extends EventEmitter {
       }
     };
 
-    this.eventEmitter.emit(EVENT_CALL_RESUMED);
+    this.emit(EVENT_CALL_RESUMED);
 
     return promise.then(() => {
       const stream = this.getLocalVideoStream();
@@ -261,7 +328,7 @@ class Call extends EventEmitter {
     logger.info('call - turn camera on', { id: this.id });
     toggleVideo(this.sipCall, true);
 
-    this.eventEmitter.emit(EVENT_CAMERA_RESUMED);
+    this.emit(EVENT_CAMERA_RESUMED);
   }
 
   turnCameraOff(): void {
@@ -269,15 +336,39 @@ class Call extends EventEmitter {
     logger.info('call -  turn camera off', { id: this.id });
     toggleVideo(this.sipCall, false);
 
-    this.eventEmitter.emit(EVENT_CAMERA_DISABLED);
+    this.emit(EVENT_CAMERA_DISABLED);
+  }
+
+  isMuted() {
+    return this._hasEstablishedState(EstablishedStates.MUTED);
+  }
+
+  isCameraMuted() {
+    return isVideoMuted(this.sipCall);
   }
 
   isHeld() {
-    return getState(this.callActor) === EstablishedStates.HELD;
+    return this._hasEstablishedState(EstablishedStates.HELD);
+  }
+
+  isEstablishing() {
+    return this.sipCall.state === SessionState.Establishing;
   }
 
   isEstablished() {
-    return getState(this.callActor) === States.ESTABLISHED;
+    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 {
@@ -288,7 +379,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 {
@@ -446,7 +537,7 @@ class Call extends EventEmitter {
       console.warn(e);
     }
 
-    this.eventEmitter.emit(EVENT_SHARE_SCREEN_ENDED);
+    this.emit(EVENT_SHARE_SCREEN_ENDED);
     this.currentScreenShare = null;
 
     return reinvited;
@@ -459,9 +550,15 @@ class Call extends EventEmitter {
     this._onScreenSharing(localStream as MediaStream, false, desktop);
   }
 
+  onMakeCall() {
+    this._bindEvents();
+
+    this._sendAction(Actions.MAKE_CALL);
+  }
+
   onAccepted() {
     this._sendAction(Actions.REMOTLY_ACCEPTED);
-    this.emit(EVENT_CALL_ACCEPTED);
+    this.emit(EVENT_CALL_REMOTLY_ACCEPTED);
   }
 
   onProgress() {
@@ -480,12 +577,18 @@ class Call extends EventEmitter {
     this.emit(EVENT_CALL_ERROR, error);
   }
 
+  onCallIncoming() {
+    this._bindEvents();
+
+    this._sendAction(Actions.INCOMING_CALL);
+  }
+
   onRejected() {
     this.endTime = new Date();
 
     this.emit(EVENT_CALL_REJECTED);
 
-    this.phone.removeCall(this);
+    this.phone.onCallTerminated(this);
   }
 
   onNetworkStats(stats: Record<string, any>, previousStats: Record<string, any>) {
@@ -528,17 +631,32 @@ class Call extends EventEmitter {
     this.emit(EVENT_REINVITE, request, updatedCalleeName, updatedNumber, hadRemoteVideo);
   }
 
+  updateFrom(call: Call) {
+    updateFrom(this, call);
+  }
+
+  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 number() {
-    const identity = this.sipCall.remoteIdentity || this.sipCall.assertedIdentity;
-    // @ts-ignore: private
-    return identity ? identity.uri._normal.user : null;
+  get state(): StateTypes | Record<StateTypes, EstablishedStateTypes> {
+    return getState(this.callActor) as StateTypes | Record<StateTypes, EstablishedStateTypes>;
   }
 
-  _bindEvents() {
+  private _hasEstablishedState(establishedState: EstablishedStateTypes) {
+    const state = this.state as Record<StateTypes, EstablishedStateTypes>;
+    return typeof state === 'object' && States.ESTABLISHED in state && state[States.ESTABLISHED] === establishedState;
+  }
+
+  private _bindEvents() {
     if (this.sipCall instanceof Invitation) {
       // Monkey patch to know when canceled with the CANCEL message
       const onCancel = (this.sipCall as Invitation)._onCancel.bind(this.sipCall);
@@ -548,15 +666,15 @@ class Call extends EventEmitter {
         onCancel(message);
         const elsewhere = message.data.indexOf('cause=26') !== -1 && message.data.indexOf('completed elsewhere') !== -1;
 
-        this.eventEmitter.emit(EVENT_CALL_CANCELED, elsewhere);
+        this.emit(EVENT_CALL_CANCELED, elsewhere);
       };
     }
 
-    this.sipCall.stateChange.addListener((newState: SessionState) => {
+    this.sipCall?.stateChange?.addListener((newState: SessionState) => {
       switch (newState) {
         case SessionState.Terminating:
           logger.info('call - terminating', { id: this.id });
-          this.eventEmitter.emit(EVENT_CALL_TERMINATING);
+          this.emit(EVENT_CALL_TERMINATING);
           break;
 
         case SessionState.Terminated:
@@ -566,7 +684,9 @@ class Call extends EventEmitter {
           // Should be called before `_onCallTerminated` or the callCount will not decrement...
           this.endTime = new Date();
 
-          return this.eventEmitter.emit(EVENT_CALL_ENDED);
+          this.emit(EVENT_CALL_ENDED);
+
+          return this.phone.onCallTerminated(this);
         }
 
         default:
@@ -599,10 +719,10 @@ class Call extends EventEmitter {
       });
 
       if (kind === 'audio') {
-        return this.eventEmitter.emit(EVENT_AUDIO_STREAM, stream);
+        return this.emit(EVENT_AUDIO_STREAM, stream);
       }
 
-      return this.eventEmitter.emit(EVENT_VIDEO_STREAM, stream, event.track.id, event);
+      return this.emit(EVENT_VIDEO_STREAM, stream, event.track.id, event);
     };
 
     peerConnection.onremovestream = (event: any) => {
@@ -610,13 +730,11 @@ class Call extends EventEmitter {
         id: event.stream.id,
         tracks: event.stream.getTracks(),
       });
-      this.eventEmitter.emit(EVENT_REMOVE_STREAM, event.stream);
+      this.emit(EVENT_REMOVE_STREAM, event.stream);
     };
-
-    // Client events
   }
 
-  _downgradeToAudio(withMessage = true) {
+  private _downgradeToAudio(withMessage = true) {
     assertState(this.callActor, States.ESTABLISHED);
     logger.info('call - downgrade to audio', { id: this.id, withMessage });
 
@@ -630,7 +748,7 @@ class Call extends EventEmitter {
   }
 
   // Returns true if we need to send a re-INVITE request
-  async _upgradeToVideo(options: ReinviteOptions = {}): Promise<boolean> {
+  private async _upgradeToVideo(options: ReinviteOptions = {}): Promise<boolean> {
     assertState(this.callActor, States.ESTABLISHED);
     logger.info('call - upgrade to video', { id: this.id, ...options });
 
@@ -660,7 +778,7 @@ class Call extends EventEmitter {
     return false;
   }
 
-  _sendReinviteMessage(isUpgrade: boolean) {
+  private _sendReinviteMessage(isUpgrade: boolean) {
     assertState(this.callActor, States.ESTABLISHED);
     logger.info('call - sending reinvite message', { id: this.id, isUpgrade });
 
@@ -679,7 +797,7 @@ class Call extends EventEmitter {
     }, 2500);
   }
 
-  _onScreenSharing(screenStream: MediaStream, hadVideo: boolean, desktop?: boolean | null | undefined) {
+  private _onScreenSharing(screenStream: MediaStream, hadVideo: boolean, desktop?: boolean | null | undefined) {
     const screenTrack = screenStream.getVideoTracks()[0];
     const pc = this.phone.client.getPeerConnection(this.id);
     const sender = pc && pc.getSenders && pc.getSenders().find((s) => s && s.track && s.track.kind === 'video');
@@ -690,7 +808,7 @@ class Call extends EventEmitter {
       screenTrack.onended = () => {
         logger.info('call - on screenshare ended', { hadVideo, id: this.id, screenTrack });
 
-        this.eventEmitter.emit(EVENT_SHARE_SCREEN_ENDING);
+        this.emit(EVENT_SHARE_SCREEN_ENDING);
       };
     }
 
@@ -702,11 +820,13 @@ class Call extends EventEmitter {
     };
 
     setLocalMediaStream(this.sipCall, screenStream);
-    this.eventEmitter.emit(EVENT_SHARE_SCREEN_STARTED, screenStream);
+    this.emit(EVENT_SHARE_SCREEN_STARTED, screenStream);
   }
 
-  _sendAction(action: ActionTypes | EstablishedActionTypes) {
+  private _sendAction(action: ActionTypes | EstablishedActionTypes) {
+    const was = this.state;
     this.callActor.send({ type: action });
+    logger.trace('call - send action', { action, was, state: this.state });
   }
 }