@signalwire/js 3.26.0 → 3.27.0-dev.202404301530.94a97d7.0

package/src/fabric/IncomingCallManager.ts

@@ -0,0 +1,89 @@
+import { BaseRoomSession } from '../BaseRoomSession'
+import { RoomSession } from '../RoomSession'
+import {
+  CallOptions,
+  IncomingCallHandlers,
+  IncomingCallNotification,
+  IncomingInvite,
+} from './types'
+
+export class IncomingCallManager {
+  private _pendingInvites: Record<string, IncomingInvite> = {}
+  private _handlers: IncomingCallHandlers = {}
+
+  constructor(
+    private _buildCallObject: (
+      invite: IncomingInvite,
+      params: CallOptions
+    ) => BaseRoomSession<RoomSession>,
+    private _executeReject: (callId: string, nodeId: string) => Promise<void>
+  ) {}
+
+  private _buildNotification(invite: IncomingInvite): IncomingCallNotification {
+    const accept = async (params: CallOptions) => {
+      return new Promise<BaseRoomSession<RoomSession>>((resolve, reject) => {
+        delete this._pendingInvites[invite.callID]
+        try {
+          const call = this._buildCallObject(invite, params)
+          //@ts-expect-error
+          call.answer()
+
+          resolve(call)
+        } catch (e) {
+          reject(e)
+        }
+      })
+    }
+
+    const reject = () => {
+      delete this._pendingInvites[invite.callID]
+      return this._executeReject(invite.callID, invite.nodeId)
+    }
+
+    return {
+      invite: {
+        details: invite,
+        accept: (params) => accept(params),
+        reject: () => reject(),
+      },
+    }
+  }
+
+  setNotificationHandlers(handlers: IncomingCallHandlers) {
+    this._handlers.all = handlers.all
+    if (
+      (handlers.pushNotification &&
+        this._handlers.all != handlers.pushNotification) ||
+      !handlers.pushNotification
+    ) {
+      this._handlers.pushNotification = handlers.pushNotification
+    }
+    if (
+      (handlers.websocket && this._handlers.all != handlers.websocket) ||
+      !handlers.websocket
+    ) {
+      this._handlers.websocket = handlers.websocket
+    }
+  }
+
+  handleIncomingInvite(incomingInvite: IncomingInvite) {
+    if (incomingInvite.callID in this._pendingInvites) {
+      console.log(
+        `skiping nottification for pending invite to callID: ${incomingInvite.callID}`
+      )
+      return
+    }
+    this._pendingInvites[incomingInvite.callID] = incomingInvite
+
+    if (!(this._handlers.all || this._handlers[incomingInvite.source])) {
+      console.log('skiping nottification no listeners:')
+      return
+    }
+
+    const notification = this._buildNotification(incomingInvite)
+
+    this._handlers.all?.(notification)
+    const handler = this._handlers[incomingInvite.source]
+    handler?.(notification)
+  }
+}

package/src/fabric/SignalWire.ts

@@ -1,20 +1,7 @@
-import { type UserOptions } from '@signalwire/core'
 import { HTTPClient } from './HTTPClient'
-import { WSClient, WSClientOptions } from './WSClient'
-
-export interface SignalWireOptions extends UserOptions, WSClientOptions {}
-
-export interface SignalWireContract {
-  httpHost: HTTPClient['httpHost']
-  getAddresses: HTTPClient['getAddresses']
-  registerDevice: HTTPClient['registerDevice']
-  unregisterDevice: HTTPClient['unregisterDevice']
-  connect: WSClient['connect']
-  disconnect: WSClient['disconnect']
-  dial: WSClient['dial']
-  handlePushNotification: WSClient['handlePushNotification']
-  updateToken: WSClient['updateToken']
-}
+import { WSClient } from './WSClient'
+import { Conversation } from './Conversation'
+import { SignalWireContract, SignalWireOptions } from './types'
 
 export const SignalWire = (
   options: SignalWireOptions
@@ -24,16 +11,32 @@ export const SignalWire = (
       const httpClient = new HTTPClient(options)
       const wsClient = new WSClient(options)
 
+      const conversation = new Conversation({ httpClient, wsClient })
+
       resolve({
         httpHost: httpClient.httpHost,
-        getAddresses: httpClient.getAddresses.bind(httpClient),
         registerDevice: httpClient.registerDevice.bind(httpClient),
         unregisterDevice: httpClient.unregisterDevice.bind(httpClient),
+        getSubscriberInfo: httpClient.getSubscriberInfo.bind(httpClient),
         connect: wsClient.connect.bind(wsClient),
         disconnect: wsClient.disconnect.bind(wsClient),
+        online: wsClient.online.bind(wsClient),
+        offline: wsClient.offline.bind(wsClient),
         dial: wsClient.dial.bind(wsClient),
         handlePushNotification: wsClient.handlePushNotification.bind(wsClient),
         updateToken: wsClient.updateToken.bind(wsClient),
+        address: {
+          getAddresses: httpClient.getAddresses.bind(httpClient),
+          getAddress: httpClient.getAddress.bind(httpClient),
+        },
+        conversation: {
+          getConversations: conversation.getConversations.bind(conversation),
+          getMessages: conversation.getMessages.bind(conversation),
+          getConversationMessages:
+            conversation.getConversationMessages.bind(conversation),
+          subscribe: conversation.subscribe.bind(conversation),
+          sendMessage: conversation.sendMessage.bind(conversation),
+        },
         // @ts-expect-error
         __httpClient: httpClient,
         __wsClient: wsClient,

package/src/fabric/WSClient.ts

@@ -1,85 +1,71 @@
-import { type UserOptions, getLogger, VertoSubscribe } from '@signalwire/core'
+import { getLogger, VertoSubscribe, VertoBye } from '@signalwire/core'
+import { Client } from '../Client'
+import { RoomSession } from '../RoomSession'
 import { createClient } from '../createClient'
-import { WSClientWorker } from './WSClientWorker'
-
-interface PushNotification {
-  encryption_type: 'aes_256_gcm'
-  notification_uuid: string
-  with_video: 'true' | 'false'
-  incoming_caller_name: string
-  incoming_caller_id: string
-  tag: string
-  invite: string
-  title: string
-  type: 'call_invite'
-  iv: string
-  version: string
-  decrypted: Record<string, any>
-}
-
-export interface WSClientOptions extends UserOptions {
-  /** HTML element in which to display the video stream */
-  rootElement?: HTMLElement
-  /** Disable ICE UDP transport policy */
-  disableUdpIceServers?: boolean
-}
+import { wsClientWorker } from './workers'
+import {
+  CallOptions,
+  DialParams,
+  InboundCallSource,
+  IncomingInvite,
+  OnlineParams,
+  PushNotificationPayload,
+  WSClientOptions,
+} from './types'
+import { IncomingCallManager } from './IncomingCallManager'
 
 export class WSClient {
-  private wsClient: ReturnType<typeof createClient>
+  private wsClient: Client<RoomSession>
   private logger = getLogger()
+  private _incomingCallManager: IncomingCallManager
 
   constructor(public options: WSClientOptions) {
-    this.wsClient = createClient({
-      host: this.options.host,
-      token: this.options.token,
-      debug: {
-        logWsTraffic: true,
-      },
-      logLevel: 'debug',
+    this.wsClient = createClient<RoomSession>({
+      ...this.options,
+      unifiedEventing: true,
     })
+    this._incomingCallManager = new IncomingCallManager(
+      (payload: IncomingInvite, params: CallOptions) =>
+        this.buildInboundCall(payload, params),
+      (callId: string, nodeId: string) => this.executeVertoBye(callId, nodeId)
+    )
+  }
+
+  /** @internal */
+  get clientApi() {
+    return this.wsClient
   }
 
-  connect() {
+  async connect() {
     // @ts-ignore
-    this.wsClient.runWorker('WSClientWorker', {
-      worker: WSClientWorker,
-    })
-    return this.wsClient.connect()
+    if (!this.wsClient.connected) {
+      // @ts-ignore
+      this.wsClient.runWorker('wsClientWorker', {
+        worker: wsClientWorker,
+        initialState: {
+          buildInboundCall: (incomingInvite: Omit<IncomingInvite, 'source'>) =>
+            this.notifyIncomingInvite('websocket', incomingInvite),
+        },
+      })
+      await this.wsClient.connect()
+    }
   }
 
   disconnect() {
     return this.wsClient.disconnect()
   }
 
-  async dial(params: { to: string; nodeId?: string }) {
+  async dial(params: DialParams) {
     return new Promise(async (resolve, reject) => {
       try {
-        console.log('WSClient dial with:', params)
-
         await this.connect()
-
-        // const {
-        //   audio: audioFromConstructor = true,
-        //   video: videoFromConstructor = true,
-        //   iceServers,
-        //   rootElement,
-        //   applyLocalVideoOverlay = true,
-        //   stopCameraWhileMuted = true,
-        //   stopMicrophoneWhileMuted = true,
-        //   speakerId,
-        //   destinationNumber,
-        //   watchMediaPackets,
-        //   watchMediaPacketsTimeout,
-        //   ...userOptions
-        // } = params
-
         const call = this.wsClient.rooms.makeRoomObject({
-          // audio,
-          // video: video === true ? VIDEO_CONSTRAINTS : video,
+          audio: params.audio ?? true,
+          video: params.video ?? true,
           negotiateAudio: true,
           negotiateVideo: true,
           // iceServers,
-          rootElement: this.options.rootElement,
+          rootElement: params.rootElement,
           applyLocalVideoOverlay: true,
           stopCameraWhileMuted: true,
           stopMicrophoneWhileMuted: true,
@@ -88,7 +74,8 @@ export class WSClient {
           watchMediaPackets: false,
           // watchMediaPacketsTimeout:,
           nodeId: params.nodeId,
-          disableUdpIceServers: this.options.disableUdpIceServers || false,
+          disableUdpIceServers: params.disableUdpIceServers || false,
+          unifiedEventing: true,
         })
 
         // WebRTC connection left the room.
@@ -107,14 +94,11 @@ export class WSClient {
         call.start = () => {
           return new Promise(async (resolve, reject) => {
             try {
-              // @ts-expect-error
-              call.once('verto.display', () => resolve(call))
               call.once('room.subscribed', () => resolve(call))
 
               await call.join()
             } catch (error) {
               getLogger().error('WSClient call start', error)
-
               reject(error)
             }
           })
@@ -129,7 +113,7 @@ export class WSClient {
     })
   }
 
-  handlePushNotification(payload: PushNotification) {
+  handlePushNotification(payload: PushNotificationPayload) {
     return new Promise(async (resolve, reject) => {
       const { decrypted, type } = payload
       if (type !== 'call_invite') {
@@ -149,15 +133,6 @@ export class WSClient {
           display_direction,
         },
       } = jsonrpc
-      this.logger.debug('handlePushNotification data', {
-        callID,
-        sdp,
-        caller_id_name,
-        caller_id_number,
-        callee_id_name,
-        callee_id_number,
-        display_direction,
-      })
       try {
         // Connect the client first
         await this.connect()
@@ -170,58 +145,54 @@ export class WSClient {
           this.logger.warn('Verto Subscribe', error)
         }
 
-        // Build the Call object and return to the user
-
-        // const {
-        //   audio: audioFromConstructor = true,
-        //   video: videoFromConstructor = true,
-        //   iceServers,
-        //   rootElement,
-        //   applyLocalVideoOverlay = true,
-        //   stopCameraWhileMuted = true,
-        //   stopMicrophoneWhileMuted = true,
-        //   speakerId,
-        //   destinationNumber,
-        //   watchMediaPackets,
-        //   watchMediaPacketsTimeout,
-        //   ...userOptions
-        // } = params
-
-        const call = this.wsClient.rooms.makeRoomObject({
-          negotiateAudio: true,
-          negotiateVideo: true,
-          rootElement: this.options.rootElement,
-          applyLocalVideoOverlay: true,
-          stopCameraWhileMuted: true,
-          stopMicrophoneWhileMuted: true,
-          // speakerId,
-          watchMediaPackets: false,
-          // watchMediaPacketsTimeout:,
-
-          remoteSdp: sdp,
-          prevCallId: callID,
+        this.notifyIncomingInvite('pushNotification', {
+          callID,
+          sdp,
+          caller_id_name,
+          caller_id_number,
+          callee_id_name,
+          callee_id_number,
+          display_direction,
           nodeId,
         })
-
-        // WebRTC connection left the room.
-        call.once('destroy', () => {
-          getLogger().debug('RTC Connection Destroyed')
-        })
-
-        // @ts-expect-error
-        call.attachPreConnectWorkers()
-
-        // // @ts-expect-error
-        // call.attachOnSubscribedWorkers(payload)
-
-        getLogger().debug('Resolving Call', call)
-        resolve({ resultType: 'inboundCall', resultObject: call })
+        resolve({ resultType: 'inboundCall' })
       } catch (error) {
         reject(error)
       }
     })
   }
 
+  private notifyIncomingInvite(
+    source: InboundCallSource,
+    buildCallParams: Omit<IncomingInvite, 'source'>
+  ) {
+    this._incomingCallManager.handleIncomingInvite({
+      source,
+      ...buildCallParams,
+    })
+  }
+
+  private async executeVertoBye(callId: string, nodeId: string) {
+    try {
+      // @ts-expect-error
+      return await this.wsClient.execute({
+        method: 'webrtc.verto',
+        params: {
+          callID: callId,
+          node_id: nodeId,
+          message: VertoBye({
+            cause: 'USER_BUSY',
+            causeCode: '17',
+            dialogParams: { callID: callId },
+          }),
+        },
+      })
+    } catch (error) {
+      this.logger.warn('The call is not available anymore', callId)
+      throw error
+    }
+  }
+
   private async executeVertoSubscribe(callId: string, nodeId: string) {
     try {
       // @ts-expect-error
@@ -243,6 +214,44 @@ export class WSClient {
     }
   }
 
+  private buildInboundCall(payload: IncomingInvite, params: CallOptions) {
+    getLogger().debug('Build new call to answer')
+
+    const { callID, nodeId, sdp } = payload
+
+    const call = this.wsClient.rooms.makeRoomObject({
+      audio: params.audio ?? true,
+      video: params.video ?? true,
+      negotiateAudio: true,
+      negotiateVideo: true,
+      rootElement: params.rootElement,
+      applyLocalVideoOverlay: true,
+      stopCameraWhileMuted: true,
+      stopMicrophoneWhileMuted: true,
+      watchMediaPackets: false,
+      remoteSdp: sdp,
+      prevCallId: callID,
+      nodeId,
+      disableUdpIceServers: params.disableUdpIceServers || false,
+      unifiedEventing: true,
+    })
+
+    // WebRTC connection left the room.
+    call.once('destroy', () => {
+      getLogger().debug('RTC Connection Destroyed')
+    })
+
+    // @ts-expect-error
+    call.attachPreConnectWorkers()
+
+    getLogger().debug('Resolving Call', call)
+
+    return call
+  }
+
+  /**
+   * Allow user to update the auth token
+   */
   updateToken(token: string): Promise<void> {
     return new Promise((resolve, reject) => {
       this.wsClient.once('session.auth_error', (error) => {
@@ -256,4 +265,31 @@ export class WSClient {
       this.wsClient.reauthenticate(token)
     })
   }
+
+  /**
+   * Mark the client as 'online' to receive calls over WebSocket
+   */
+  async online({ incomingCallHandlers }: OnlineParams) {
+    this._incomingCallManager.setNotificationHandlers(incomingCallHandlers)
+
+    await this.connect()
+
+    // @ts-expect-error
+    return this.wsClient.execute({
+      method: 'subscriber.online',
+      params: {},
+    })
+  }
+
+  /**
+   * Mark the client as 'offline' to receive calls over WebSocket
+   */
+  offline() {
+    this._incomingCallManager.setNotificationHandlers({})
+    // @ts-expect-error
+    return this.wsClient.execute({
+      method: 'subscriber.offline',
+      params: {},
+    })
+  }
 }

package/src/fabric/createHttpClient.ts

@@ -48,6 +48,8 @@ interface HttpClientRequestInit extends Omit<RequestInit, 'body'> {
   searchParams?: Record<string, any>
 }
 
+export type CreateHttpClient = ReturnType<typeof createHttpClient>
+
 export const createHttpClient = (
   { baseUrl, timeout = 30000, ...globalOptions }: CreateHttpClientOptions,
   fetcher = http

package/src/fabric/index.ts

@@ -1,4 +1,7 @@
 export * from './Client'
 export * from './SWClient'
 export * from './WSClient'
+export * from './HTTPClient'
 export * from './SignalWire'
+export * from './IncomingCallManager'
+export * from './ConversationAPI'

package/src/fabric/types.ts

@@ -0,0 +1,104 @@
+import { type UserOptions } from '@signalwire/core'
+import { BaseRoomSession } from '../BaseRoomSession'
+import { RoomSession } from '../video'
+import { HTTPClient } from './HTTPClient'
+import { WSClient } from './WSClient'
+import { Conversation } from './Conversation'
+
+export interface SignalWireOptions extends WSClientOptions {}
+
+export interface SignalWireContract {
+  httpHost: HTTPClient['httpHost']
+  registerDevice: HTTPClient['registerDevice']
+  unregisterDevice: HTTPClient['unregisterDevice']
+  getSubscriberInfo: HTTPClient['getSubscriberInfo']
+  connect: WSClient['connect']
+  disconnect: WSClient['disconnect']
+  online: WSClient['online']
+  offline: WSClient['offline']
+  dial: WSClient['dial']
+  handlePushNotification: WSClient['handlePushNotification']
+  updateToken: WSClient['updateToken']
+  address: {
+    getAddresses: HTTPClient['getAddresses']
+    getAddress: HTTPClient['getAddress']
+  }
+  conversation: {
+    getConversations: Conversation['getConversations']
+    getMessages: Conversation['getMessages']
+    getConversationMessages: Conversation['getConversationMessages']
+    subscribe: Conversation['subscribe']
+    sendMessage: Conversation['sendMessage']
+  }
+}
+
+export interface OnlineParams {
+  incomingCallHandlers: IncomingCallHandlers
+}
+
+export interface PushNotificationPayload {
+  encryption_type: 'aes_256_gcm'
+  notification_uuid: string
+  with_video: 'true' | 'false'
+  incoming_caller_name: string
+  incoming_caller_id: string
+  tag: string
+  invite: string
+  title: string
+  type: 'call_invite'
+  iv: string
+  version: string
+  decrypted: Record<string, any>
+}
+
+export interface CallOptions {
+  /** HTML element in which to display the video stream */
+  rootElement?: HTMLElement
+  /** Disable ICE UDP transport policy */
+  disableUdpIceServers?: boolean
+  /** Audio constraints to use when joining the room. Default: `true`. */
+  audio?: MediaStreamConstraints['audio']
+  /** Video constraints to use when joining the room. Default: `true`. */
+  video?: MediaStreamConstraints['video']
+}
+
+export interface DialParams extends CallOptions {
+  to: string
+  nodeId?: string
+}
+
+export interface WSClientOptions extends UserOptions {
+  /** Call back function to receive the incoming call */
+  incomingCallHandlers?: IncomingCallHandlers
+}
+
+export type InboundCallSource = 'websocket' | 'pushNotification'
+
+export interface IncomingInvite {
+  source: InboundCallSource
+  callID: string
+  sdp: string
+  caller_id_name: string
+  caller_id_number: string
+  callee_id_name: string
+  callee_id_number: string
+  display_direction: string
+  nodeId: string
+}
+
+export interface IncomingCallNotification {
+  invite: {
+    details: IncomingInvite
+    accept: (param: CallOptions) => Promise<BaseRoomSession<RoomSession>>
+    reject: () => Promise<void>
+  }
+}
+export type IncomingCallHandler = (
+  notification: IncomingCallNotification
+) => Promise<void>
+
+export interface IncomingCallHandlers {
+  all?: IncomingCallHandler
+  pushNotification?: IncomingCallHandler
+  websocket?: IncomingCallHandler
+}