@wazo/sdk 0.43.6 → 1.0.0-alpha.1

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

@@ -0,0 +1,131 @@
+import { setup, type ActorRefFrom } from 'xstate';
+
+import softphone from '../voice/softphone';
+import { States as SoftphoneStates } from './softphone-state-machine';
+
+export const States = {
+  IDLE: 'idle',
+  RINGING: 'ringing',
+  IN_PROGRESS: 'progress',
+  ESTABLISHED: 'established',
+  TERMINATED: 'terminated',
+} as const;
+
+export const EstablishedStates = {
+  ONGOING: 'ongoing',
+  HELD: 'held',
+  MUTED: 'muted',
+} as const;
+
+export type StateTypes = typeof States[keyof typeof States];
+
+export type EstablishedStateTypes = typeof EstablishedStates[keyof typeof EstablishedStates];
+
+export const Actions = {
+  INCOMING_CALL: 'incomingCall',
+  MAKE_CALL: 'makeCall',
+  ACCEPT: 'accept',
+  REMOTLY_ACCEPTED: 'remotlyAccepted',
+  REJECT: 'reject',
+  HANGUP: 'hangup',
+} as const;
+
+export const EstablishedActions = {
+  HOLD: 'hold',
+  RESUME: 'resume',
+  MUTE: 'mute',
+  UN_MUTE: 'unMute',
+} as const;
+
+export type ActionTypes = typeof Actions[keyof typeof Actions];
+
+export type EstablishedActionTypes = typeof EstablishedActions[keyof typeof EstablishedActions];
+
+const callMachine = setup({
+  guards: {
+    isRegistered: () => softphone.getState() === SoftphoneStates.REGISTERED,
+  },
+}).createMachine({
+  id: 'call',
+  initial: States.IDLE,
+  context: {},
+  states: {
+    [States.IDLE]: {
+      on: {
+        [Actions.INCOMING_CALL]: {
+          // guard: 'isRegistered',
+          target: States.RINGING,
+        },
+        [Actions.MAKE_CALL]: {
+          guard: 'isRegistered',
+          target: States.IN_PROGRESS,
+        },
+      },
+    },
+    [States.IN_PROGRESS]: {
+      on: {
+        [Actions.HANGUP]: {
+          guard: 'isRegistered',
+          target: States.TERMINATED,
+        },
+        [Actions.REMOTLY_ACCEPTED]: {
+          guard: 'isRegistered',
+          target: States.ESTABLISHED,
+        },
+      },
+    },
+    [States.RINGING]: {
+      on: {
+        [Actions.ACCEPT]: {
+          guard: 'isRegistered',
+          target: States.ESTABLISHED,
+        },
+        [Actions.REJECT]: {
+          guard: 'isRegistered',
+          target: States.TERMINATED,
+        },
+      },
+    },
+    [States.ESTABLISHED]: {
+      initial: EstablishedStates.ONGOING,
+      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,
+            },
+          },
+        },
+        [EstablishedStates.MUTED]: {
+          on: {
+            [EstablishedActions.UN_MUTE]: {
+              guard: 'isRegistered',
+              target: EstablishedStates.ONGOING,
+            },
+          },
+        },
+      },
+    },
+    [States.TERMINATED]: { },
+  },
+});
+
+export type CallActorRef = ActorRefFrom<typeof callMachine>;
+
+export default callMachine;

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

@@ -0,0 +1,49 @@
+import { type ActorRefFrom, setup } from 'xstate';
+
+export const States = {
+  UNREGISTERED: 'unregistered',
+  REGISTERING: 'registering',
+  REGISTERED: 'registered',
+} as const;
+
+export type StateTypes = typeof States[keyof typeof States];
+
+export const Actions = {
+  REGISTER: 'register',
+  REGISTER_DONE: 'registerDone',
+  UNREGISTER: 'unregister',
+  UNREGISTERED: 'unregistered',
+  TRANSPORT_CLOSED: 'transportClosed',
+} as const;
+
+export type ActionTypes = typeof Actions[keyof typeof Actions];
+
+const softphoneMachine = setup({}).createMachine({
+  id: 'softphone',
+  initial: States.UNREGISTERED,
+  context: {},
+  states: {
+    [States.UNREGISTERED]: {
+      on: {
+        [Actions.REGISTER]: States.REGISTERING,
+      },
+    },
+    [States.REGISTERING]: {
+      on: {
+        [Actions.REGISTER_DONE]: States.REGISTERED,
+        [Actions.TRANSPORT_CLOSED]: States.UNREGISTERED,
+        [Actions.UNREGISTERED]: States.UNREGISTERED,
+      },
+    },
+    [States.REGISTERED]: {
+      on: {
+        [Actions.UNREGISTER]: States.UNREGISTERED,
+        [Actions.TRANSPORT_CLOSED]: States.UNREGISTERED,
+      },
+    },
+  },
+});
+
+export type SoftphoneActorRef = ActorRefFrom<typeof softphoneMachine>;
+
+export default softphoneMachine;

package/src/state-machine/utils.ts

@@ -0,0 +1,53 @@
+import { type SnapshotFrom } from 'xstate';
+import { type SoftphoneActorRef, type ActionTypes as SoftphoneActions, type StateTypes as SoftphoneStates } from './softphone-state-machine';
+import { type CallActorRef, type ActionTypes as CallActions, type EstablishedActionTypes as EstablishedCallActions, type StateTypes as CallStates, type EstablishedStateTypes } from './call-state-machine';
+
+import InvalidStateTransition from '../domain/InvalidStateTransition';
+import InvalidState from '../domain/InvalidState';
+import IssueReporter from '../service/IssueReporter';
+
+const logger = IssueReporter.loggerFor('state-machine');
+
+export const getState = (actor: SoftphoneActorRef | CallActorRef): SoftphoneStates | CallStates | EstablishedStateTypes => {
+  return actor.getSnapshot().value as SoftphoneStates | CallStates | EstablishedStateTypes;
+};
+
+export const can = (actor: SoftphoneActorRef | CallActorRef, action: SoftphoneActions | CallActions | EstablishedCallActions): boolean => {
+  return actor.getSnapshot().can({ type: action });
+};
+
+export const hasState = (actor: SoftphoneActorRef | CallActorRef, state: SoftphoneStates | CallStates): boolean => {
+  return getState(actor) === state;
+};
+
+export const waitUntilState = (actor: SoftphoneActorRef | CallActorRef, state: SoftphoneStates | CallStates, timeout = 5000): Promise<unknown> => {
+  return Promise.race([
+    new Promise(resolve => {
+      (actor as SoftphoneActorRef).subscribe((snapshot: SnapshotFrom<SoftphoneActorRef | CallActorRef>) => {
+        if (snapshot.value === state) {
+          resolve(null);
+        }
+      });
+    }),
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`Waited for state ${state} timeout.`)), timeout)),
+  ]);
+};
+
+export const assertCan = (actor: SoftphoneActorRef | CallActorRef, action: SoftphoneActions | CallActions | EstablishedCallActions): void => {
+  if (!can(actor, action)) {
+    const currentState = actor.getSnapshot().value;
+    const message = `Invalid state transition from ${currentState} with action ${action}`;
+    logger.warn(message);
+
+    throw new InvalidStateTransition(message, action, currentState as string);
+  }
+};
+
+export const assertState = (actor: SoftphoneActorRef | CallActorRef, state: SoftphoneStates | CallStates): void => {
+  if (!hasState(actor, state)) {
+    const message = `Invalid state ${state}`;
+    logger.warn(message);
+
+    throw new InvalidState(message, state);
+  }
+};

package/src/utils/sdp.ts

@@ -1,4 +1,11 @@
 import sdpParser from 'sdp-transform';
+import { UserAgent } from 'sip.js/lib/api/user-agent';
+import { Inviter } from 'sip.js/lib/api';
+import { URI } from 'sip.js/lib/grammar/uri';
+
+import type { SipCall } from '../domain/types';
+
+export const SIP_ID_LENGTH = 36;
 
 export type Candidate = {
   foundation: string;
@@ -138,3 +145,32 @@ export const addIcesInAllBundles = (sdp: string) => {
   }));
   return sdpParser.write(parsedSdp);
 };
+
+export const getSipSessionId = (sipSession: SipCall | null | undefined): string => {
+  if (!sipSession) {
+    return '';
+  }
+
+  const message = sipSession.message as Partial<{ callId?: string }>;
+  if (message?.callId) {
+    return message.callId.substring(0, SIP_ID_LENGTH);
+  }
+
+  // For Inviter
+  // @ts-ignore: private
+  if (sipSession instanceof Inviter && sipSession.outgoingRequestMessage) {
+    // @ts-ignore: private
+    return sipSession.outgoingRequestMessage.callId.substring(0, SIP_ID_LENGTH);
+  }
+
+  // For Invitation
+  return (sipSession.id || '').substring(0, SIP_ID_LENGTH);
+};
+
+// 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.
+  ...JSON.parse(JSON.stringify(description)),
+  sdp: description.sdp.replace('c=IN IP4 0.0.0.0', 'c=IN IP4 127.0.0.1'),
+});
+
+export const makeURI = (target: string, host: string): URI | undefined => UserAgent.makeURI(`sip:${target}@${host}`);

package/src/utils/sip-logger.ts

@@ -0,0 +1,40 @@
+import IssueReporter from '../service/IssueReporter';
+import { WebRtcConfig } from '../domain/types';
+
+const sipLogger = IssueReporter.loggerFor('sip.js');
+const protocolLogger = IssueReporter.loggerFor('sip');
+const protocolDebugMessages = ['Received WebSocket text message:', 'Sending WebSocket message:'];
+
+const logConnector = (level: any, className: string, label: any, content: string): void => {
+  const protocolIndex = content && content.indexOf ? protocolDebugMessages.findIndex(prefix => content.indexOf(prefix) !== -1) : -1;
+
+  if (className === 'sip.Transport' && protocolIndex !== -1) {
+    const direction = protocolIndex === 0 ? 'receiving' : 'sending';
+    const message = content.replace(`${protocolDebugMessages[protocolIndex]}\n\n`, '').replace('\r\n', '\n');
+    protocolLogger.trace(message, {
+      className,
+      direction,
+    });
+  } else {
+    sipLogger.trace(content, {
+      className,
+    });
+  }
+};
+
+const configureLogger = (rawOptions: Partial<WebRtcConfig> = {}): Partial<WebRtcConfig> => {
+  const options = rawOptions;
+
+  if (options.uaConfigOverrides) {
+    options.uaConfigOverrides.traceSip = true;
+  }
+  options.log = options.log || {};
+  options.log.builtinEnabled = false;
+  options.log.logLevel = 'debug';
+
+  options.log.connector = logConnector;
+
+  return options;
+};
+
+export default configureLogger;