@wazo/sdk 1.0.0-alpha.17 → 1.0.0-alpha.19

package/src/__tests__/__voice__/call.test.ts

@@ -3,7 +3,7 @@ import { Inviter, UserAgent, type URI } from 'sip.js';
 
 import softphone from '../../voice/softphone';
 import Call from '../../voice/call';
-import { Actions, EstablishedStates, States } from '../../state-machine/call-state-machine';
+import { Actions, EstablishedStates, EstablishedSubStates, States } from '../../state-machine/call-state-machine';
 import { Actions as SoftphoneActions } from '../../state-machine/softphone-state-machine';
 import ApiCall from '../../domain/Call';
 
@@ -32,6 +32,9 @@ jest.mock('../..', () => ({
 
 jest.mock('../../web-rtc-client', () => jest.fn().mockImplementation(() => ({
   answer: jest.fn(() => Promise.resolve()),
+  mute: jest.fn(() => Promise.resolve()),
+  hold: jest.fn(() => Promise.resolve()),
+  unhold: jest.fn(() => Promise.resolve()),
   hangup: jest.fn(() => Promise.resolve()),
   register: jest.fn(() => Promise.resolve()),
   onCallEnded: jest.fn(() => Promise.resolve()),
@@ -76,9 +79,16 @@ describe('Call', () => {
       expect(call.id).toBe(apiCall.sipCallId);
       expect(call.apiId).toBe(apiCall.id);
       expect(call.number).toBe(apiCall.calleeNumber);
-      expect(call.answerTime).toStrictEqual(apiCall.startingTime);
+      expect(call.answerTime).toStrictEqual(undefined);
+      expect(call.creationTime).toStrictEqual(apiCall.startingTime);
       expect(call.isMuted()).toBeTruthy();
-      expect(call.state).toStrictEqual({ [States.ESTABLISHED]: EstablishedStates.MUTED });
+      expect(call.state).toStrictEqual({
+        [States.ESTABLISHED]: {
+          [EstablishedStates.ONGOING]: {},
+          [EstablishedSubStates.MUTE]: EstablishedStates.MUTED,
+          [EstablishedSubStates.HOLD]: EstablishedStates.UN_HELD,
+        },
+      });
       expect(call.isEstablished()).toBeTruthy();
     });
   });
@@ -141,11 +151,43 @@ describe('Call', () => {
       call._sendAction(Actions.MAKE_CALL);
 
       call.on('remotelyAccepted', () => {
-        expect(call.state).toStrictEqual({ [States.ESTABLISHED]: EstablishedStates.ONGOING });
+        expect(call.state).toStrictEqual({
+          [States.ESTABLISHED]: {
+            [EstablishedStates.ONGOING]: {},
+            [EstablishedSubStates.MUTE]: EstablishedStates.UN_MUTED,
+            [EstablishedSubStates.HOLD]: EstablishedStates.UN_HELD,
+          },
+        });
         done();
       });
 
       call.onAccepted();
     });
   });
+
+  describe('Multiple sub state', () => {
+    it('Should mute and hold a call', () => {
+      const call = new Call(sipCall, softphone);
+      // @ts-ignore: private method
+      call._sendAction(Actions.MAKE_CALL);
+
+      expect(call.isMuted()).toBeFalsy();
+      expect(call.isHeld()).toBeFalsy();
+
+      // @ts-ignore: private method
+      call._sendAction(Actions.REMOTLY_ACCEPTED);
+
+      call.mute();
+      expect(call.isMuted()).toBeTruthy();
+      expect(call.isHeld()).toBeFalsy();
+
+      call.hold();
+      expect(call.isMuted()).toBeTruthy();
+      expect(call.isHeld()).toBeTruthy();
+
+      call.resume();
+      expect(call.isMuted()).toBeTruthy();
+      expect(call.isHeld()).toBeFalsy();
+    });
+  });
 });

package/src/state-machine/call-state-machine.ts

@@ -15,11 +15,19 @@ export const EstablishedStates = {
   ONGOING: 'ongoing',
   HELD: 'held',
   MUTED: 'muted',
+  UN_MUTED: 'unMuted',
+  UN_HELD: 'unHeld',
+} as const;
+
+export const EstablishedSubStates = {
+  MUTE: 'muteState',
+  HOLD: 'holdState',
 } as const;
 
 export type StateTypes = typeof States[keyof typeof States];
 
 export type EstablishedStateTypes = typeof EstablishedStates[keyof typeof EstablishedStates];
+export type EstablishedSubStateTypes = typeof EstablishedSubStates[keyof typeof EstablishedSubStates];
 
 export const Actions = {
   INCOMING_CALL: 'incomingCall',
@@ -88,35 +96,46 @@ const callMachine = setup({
     },
     [States.ESTABLISHED]: {
       initial: EstablishedStates.ONGOING,
+      type: 'parallel',
       on: {
         [Actions.HANGUP]: {
           guard: 'isRegistered',
           target: States.TERMINATED,
         },
-        [EstablishedActions.HOLD]: {
-          guard: 'isRegistered',
-          target: `.${EstablishedStates.HELD}`,
-        },
-        [EstablishedActions.MUTE]: {
-          guard: 'isRegistered',
-          target: `.${EstablishedStates.MUTED}`,
-        },
       },
       states: {
         [EstablishedStates.ONGOING]: { },
-        [EstablishedStates.HELD]: {
-          on: {
-            [EstablishedActions.RESUME]: {
-              guard: 'isRegistered',
-              target: EstablishedStates.ONGOING,
+
+        // Mute / Unmute
+        [EstablishedSubStates.MUTE]: {
+          initial: EstablishedStates.UN_MUTED,
+          states: {
+            [EstablishedStates.MUTED]: {
+              on: {
+                unMute: EstablishedStates.UN_MUTED,
+              },
+            },
+            [EstablishedStates.UN_MUTED]: {
+              on: {
+                mute: EstablishedStates.MUTED,
+              },
             },
           },
         },
-        [EstablishedStates.MUTED]: {
-          on: {
-            [EstablishedActions.UN_MUTE]: {
-              guard: 'isRegistered',
-              target: EstablishedStates.ONGOING,
+
+        // Hold / Resume
+        [EstablishedSubStates.HOLD]: {
+          initial: EstablishedStates.UN_HELD,
+          states: {
+            [EstablishedStates.HELD]: {
+              on: {
+                [EstablishedActions.RESUME]: EstablishedStates.UN_HELD,
+              },
+            },
+            [EstablishedStates.UN_HELD]: {
+              on: {
+                [EstablishedActions.HOLD]: EstablishedStates.HELD,
+              },
             },
           },
         },

package/src/utils/webrtc.ts

@@ -253,6 +253,9 @@ export const toggleVideo = (sipCall: SipCall, muteCamera: boolean): void => {
 export const isVideoMuted = (sipCall: SipCall): boolean => {
   const sdh = sipCall.sessionDescriptionHandler as SessionDescriptionHandler;
   const pc = sdh?.peerConnection as PeerConnection;
+  if (!pc) {
+    return true;
+  }
 
   if (pc?.getSenders) {
     for (const sender of pc.getSenders()) {

package/src/voice/call.ts

@@ -9,7 +9,7 @@ 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';
@@ -129,11 +129,23 @@ class Call extends EventEmitter {
     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()) {
@@ -345,7 +357,7 @@ class Call extends EventEmitter {
   }
 
   isMuted() {
-    return this._hasEstablishedState(EstablishedStates.MUTED);
+    return this._hasEstablishedState('muteState', EstablishedStates.MUTED);
   }
 
   isCameraMuted() {
@@ -353,7 +365,7 @@ class Call extends EventEmitter {
   }
 
   isHeld() {
-    return this._hasEstablishedState(EstablishedStates.HELD);
+    return this._hasEstablishedState('holdState', EstablishedStates.HELD);
   }
 
   isEstablishing() {
@@ -662,9 +674,17 @@ class Call extends EventEmitter {
     return getState(this.callActor) as StateTypes | Record<StateTypes, EstablishedStateTypes>;
   }
 
-  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 _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() {