Split state and Dial events

packages/realtime-api/src/voice/Call.ts

@@ -32,6 +32,7 @@ import {
  CallingCallStateEventParams,
  VoiceCallConnectMethodParams,
  CallingCallConnectEventParams,
+ CallingCallDialEvent,
 } from '@signalwire/core'
 import { RealTimeCallApiEvents } from '../types'
 import { AutoApplyTransformsConsumer } from '../AutoApplyTransformsConsumer'
@@ -45,6 +46,9 @@ import {
  voiceCallPromptWorker,
  voiceCallTapWorker,
  voiceCallConnectWorker,
+ voiceCallDialWorker,
+ SYNTHETIC_CALL_DIAL_ANSWERED_EVENT,
+ SYNTHETIC_CALL_DIAL_FAILED_EVENT,
 } from './workers'
 import { createCallPlaybackObject } from './CallPlayback'
 import { CallRecording, createCallRecordingObject } from './CallRecording'
@@ -126,6 +130,16 @@ export class CallConsumer extends AutoApplyTransformsConsumer<RealTimeCallApiEve
  * and apply the "peer" property to the Proxy.
  */
  })
+
+ /**
+ * It will take care of keeping instances of this class
+ * up-to-date with the latest changes sent from the
+ * server. Changes will be available to the consumer via
+ * our Proxy API.
+ */
+ this.setWorker('voiceCallStateWorker', {
+ worker: voiceCallStateWorker,
+ })
  }
 
  get id() {
@@ -292,22 +306,36 @@ export class CallConsumer extends AutoApplyTransformsConsumer<RealTimeCallApiEve
  dial(params: VoiceCallDialMethodParams) {
  return new Promise((resolve, reject) => {
  // TODO: pass resolve/reject to the worker instead of use synthetic events?
- this.setWorker('voiceCallStateWorker', {
- worker: voiceCallStateWorker,
+ this.setWorker('voiceCallDialWorker', {
+ worker: voiceCallDialWorker,
  })
  this.attachWorkers()
 
- // @ts-expect-error
- this.once(SYNTHETIC_CALL_STATE_ANSWERED_EVENT, (payload: any) => {
- this.callId = payload.call_id
+ const dialAnswerHandler = (
+ /**
+ * This event implies that dial_state === "answered",
+ * which implies `call` to be defined.
+ */
+ payload: Required<CallingCallDialEvent['params']>
+ ) => {
+ // @ts-expect-error
+ this.off(SYNTHETIC_CALL_DIAL_FAILED_EVENT, dialFailHandler)
+ this.callId = payload.call.call_id
  this.nodeId = payload.node_id
-
  resolve(this)
- })
-
- // this.once(SYNTHETIC_CALL_STATE_FAILED_EVENT, () => {
- // reject(new Error('Failed to establish the call.'))
- // })
+ }
+ const dialFailHandler = () => {
+ // @ts-expect-error
+ this.off(SYNTHETIC_CALL_DIAL_ANSWERED_EVENT, dialAnswerHandler)
+ reject(new Error('Failed to establish the call.'))
+ }
+ this.once(
+ // @ts-expect-error
+ SYNTHETIC_CALL_DIAL_ANSWERED_EVENT,
+ dialAnswerHandler
+ )
+ // @ts-expect-error
+ this.once(SYNTHETIC_CALL_DIAL_FAILED_EVENT, dialFailHandler)
 
  this.execute({
  method: 'calling.dial',
@@ -333,9 +361,6 @@ export class CallConsumer extends AutoApplyTransformsConsumer<RealTimeCallApiEve
  }
 
  // TODO: pass resolve/reject to the worker instead of use synthetic events?
- this.setWorker('voiceCallStateWorker', {
- worker: voiceCallStateWorker,
- })
  this.attachWorkers()
 
  // @ts-expect-error
@@ -366,11 +391,9 @@ export class CallConsumer extends AutoApplyTransformsConsumer<RealTimeCallApiEve
  reject(new Error('Failed to answer the call.'))
  }
 
- // TODO: pass resolve/reject to the worker instead of use synthetic events?
- this.setWorker('voiceCallStateWorker', {
- worker: voiceCallStateWorker,
- })
- this.attachWorkers({ payload: 1 })
+ // TODO: pass resolve/reject to the worker instead of
+ // use synthetic events?
+ this.attachWorkers()
 
  // @ts-expect-error
  this.once(SYNTHETIC_CALL_STATE_ANSWERED_EVENT, () => {

packages/realtime-api/src/voice/workers/index.ts

@@ -6,14 +6,19 @@ export * from './voiceCallRecordWorker'
 export * from './voiceCallPromptWorker'
 export * from './voiceCallTapWorker'
 export * from './voiceCallConnectWorker'
+export * from './voiceCallDialWorker'
 
 export const SYNTHETIC_CALL_STATE_ANSWERED_EVENT = toSyntheticEvent(
  'calling.call.answered'
 )
 
-// export const SYNTHETIC_CALL_STATE_FAILED_EVENT = toSyntheticEvent(
-// 'calling.call.failed'
-// )
-
 export const SYNTHETIC_CALL_STATE_ENDED_EVENT =
  toSyntheticEvent('calling.call.ended')
+
+export const SYNTHETIC_CALL_DIAL_ANSWERED_EVENT = toSyntheticEvent(
+ 'calling.call.dial.answered'
+)
+
+export const SYNTHETIC_CALL_DIAL_FAILED_EVENT = toSyntheticEvent(
+ 'calling.call.dial.failed'
+)

packages/realtime-api/src/voice/workers/voiceCallDialWorker.ts

@@ -0,0 +1,60 @@
+import {
+ getLogger,
+ sagaEffects,
+ SagaIterator,
+ SDKWorker,
+ SDKActions,
+ MapToPubSubShape,
+ CallingCallDialEvent,
+} from '@signalwire/core'
+import type { Call } from '../Call'
+import {
+ SYNTHETIC_CALL_DIAL_ANSWERED_EVENT,
+ SYNTHETIC_CALL_DIAL_FAILED_EVENT,
+} from './'
+
+const TARGET_DIAL_STATES: CallingCallDialEvent['params']['dial_state'][] = [
+ 'answered',
+ 'failed',
+]
+
+export const voiceCallDialWorker: SDKWorker<Call> = function* (
+ options
+): SagaIterator {
+ const { channels, instance } = options
+ const { swEventChannel, pubSubChannel } = channels
+ getLogger().trace('voiceCallDialWorker started')
+
+ const action: MapToPubSubShape<CallingCallDialEvent> = yield sagaEffects.take(
+ swEventChannel,
+ (action: SDKActions) => {
+ if (
+ action.type === 'calling.call.dial' &&
+ TARGET_DIAL_STATES.includes(action.payload.dial_state)
+ ) {
+ return instance.tag === action.payload.tag
+ }
+ return false
+ }
+ )
+
+ if (action.payload.dial_state === 'answered') {
+ yield sagaEffects.put(pubSubChannel, {
+ // @ts-expect-error
+ type: SYNTHETIC_CALL_DIAL_ANSWERED_EVENT,
+ // @ts-expect-error
+ payload: action.payload,
+ })
+ } else if (action.payload.dial_state === 'failed') {
+ yield sagaEffects.put(pubSubChannel, {
+ // @ts-expect-error
+ type: SYNTHETIC_CALL_DIAL_FAILED_EVENT,
+ // @ts-expect-error
+ payload: action.payload,
+ })
+ } else {
+ throw new Error('[voiceCallDialWorker] unhandled call_state')
+ }
+
+ getLogger().trace('voiceCallDialWorker ended')
+}

packages/realtime-api/src/voice/workers/voiceCallStateWorker.ts

@@ -7,28 +7,25 @@ import {
  CallingCallStateEvent,
  MapToPubSubShape,
 } from '@signalwire/core'
-import { Call } from '../Call'
+import type { Call } from '../Call'
 import {
  SYNTHETIC_CALL_STATE_ANSWERED_EVENT,
  SYNTHETIC_CALL_STATE_ENDED_EVENT,
 } from './'
 
-const TARGET_CALL_STATES = ['answered', 'failed', 'ended']
-
 export const voiceCallStateWorker: SDKWorker<Call> = function* (
  options
 ): SagaIterator {
  const { channels, instance } = options
  const { swEventChannel, pubSubChannel } = channels
  getLogger().trace('voiceCallStateWorker started')
 
- let isDone = false
- while (!isDone) {
+ let run = true
+ while (run) {
  const action: MapToPubSubShape<CallingCallStateEvent> =
  yield sagaEffects.take(swEventChannel, (action: SDKActions) => {
  if (
- action.type === 'calling.call.state' &&
- TARGET_CALL_STATES.includes(action.payload.call_state)
+ action.type === 'calling.call.state'
  ) {
  // To avoid mixing events on `connect` we check for `instance.id`
  // if there's already a callId value.
@@ -40,7 +37,8 @@ export const voiceCallStateWorker: SDKWorker<Call> = function* (
  return false
  })
 
- // Inject `tag` to have our EE to work because inbound calls don't have tags.
+ // Inject `tag` to have our EE to work because inbound
+ // calls don't have tags.
  const newPayload = {
  tag: instance.tag,
  ...action.payload,
@@ -62,16 +60,14 @@ export const voiceCallStateWorker: SDKWorker<Call> = function* (
  payload: newPayload,
  })
  } else if (action.payload.call_state === 'ended') {
- isDone = true
+ run = false
 
  yield sagaEffects.put(pubSubChannel, {
  // @ts-expect-error
  type: SYNTHETIC_CALL_STATE_ENDED_EVENT,
  // @ts-expect-error
  payload: newPayload,
  })
- } else {
- throw new Error('[voiceCallStateWorker] unhandled call_state')
  }
  }
  getLogger().trace('voiceCallStateWorker ended')