@telnyx/react-voice-commons-sdk 0.1.0

package/src/models/call.ts

@@ -0,0 +1,388 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { TelnyxCallState, CallStateHelpers } from './call-state';
+import { Call as TelnyxCall } from '@telnyx/react-native-voice-sdk';
+import { Platform } from 'react-native';
+
+/**
+ * Represents a call with reactive state streams.
+ *
+ * This class wraps the underlying Telnyx Call object and provides
+ * reactive streams for all call state changes, making it easy to
+ * integrate with any state management solution.
+ */
+export class Call {
+  private readonly _callState = new BehaviorSubject<TelnyxCallState>(TelnyxCallState.RINGING);
+  private readonly _isMuted = new BehaviorSubject<boolean>(false);
+  private readonly _isHeld = new BehaviorSubject<boolean>(false);
+  private readonly _duration = new BehaviorSubject<number>(0);
+
+  private _durationTimer?: NodeJS.Timeout;
+  private _startTime?: Date;
+
+  constructor(
+    private readonly _telnyxCall: TelnyxCall,
+    private readonly _callId: string,
+    private readonly _destination: string,
+    private readonly _isIncoming: boolean
+  ) {
+    this._setupCallListeners();
+  }
+
+  /**
+   * Unique identifier for this call
+   */
+  get callId(): string {
+    return this._callId;
+  }
+
+  /**
+   * The destination number or SIP URI
+   */
+  get destination(): string {
+    return this._destination;
+  }
+
+  /**
+   * Whether this is an incoming call
+   */
+  get isIncoming(): boolean {
+    return this._isIncoming;
+  }
+
+  /**
+   * Whether this is an outgoing call
+   */
+  get isOutgoing(): boolean {
+    return !this._isIncoming;
+  }
+
+  /**
+   * Current call state (synchronous access)
+   */
+  get currentState(): TelnyxCallState {
+    return this._callState.value;
+  }
+
+  /**
+   * Current mute state (synchronous access)
+   */
+  get currentIsMuted(): boolean {
+    return this._isMuted.value;
+  }
+
+  /**
+   * Current hold state (synchronous access)
+   */
+  get currentIsHeld(): boolean {
+    return this._isHeld.value;
+  }
+
+  /**
+   * Current call duration in seconds (synchronous access)
+   */
+  get currentDuration(): number {
+    return this._duration.value;
+  }
+
+  /**
+   * Get the underlying Telnyx Call object (for internal use)
+   * @internal
+   */
+  get telnyxCall(): TelnyxCall {
+    return this._telnyxCall;
+  }
+
+  /**
+   * Observable stream of call state changes
+   */
+  get callState$(): Observable<TelnyxCallState> {
+    return this._callState.asObservable().pipe(distinctUntilChanged());
+  }
+
+  /**
+   * Observable stream of mute state changes
+   */
+  get isMuted$(): Observable<boolean> {
+    return this._isMuted.asObservable().pipe(distinctUntilChanged());
+  }
+
+  /**
+   * Observable stream of hold state changes
+   */
+  get isHeld$(): Observable<boolean> {
+    return this._isHeld.asObservable().pipe(distinctUntilChanged());
+  }
+
+  /**
+   * Observable stream of call duration changes (in seconds)
+   */
+  get duration$(): Observable<number> {
+    return this._duration.asObservable().pipe(distinctUntilChanged());
+  }
+
+  /**
+   * Observable that emits true when the call can be answered
+   */
+  get canAnswer$(): Observable<boolean> {
+    return this.callState$.pipe(
+      map((state) => CallStateHelpers.canAnswer(state)),
+      distinctUntilChanged()
+    );
+  }
+
+  /**
+   * Observable that emits true when the call can be hung up
+   */
+  get canHangup$(): Observable<boolean> {
+    return this.callState$.pipe(
+      map((state) => CallStateHelpers.canHangup(state)),
+      distinctUntilChanged()
+    );
+  }
+
+  /**
+   * Observable that emits true when the call can be put on hold
+   */
+  get canHold$(): Observable<boolean> {
+    return this.callState$.pipe(
+      map((state) => CallStateHelpers.canHold(state)),
+      distinctUntilChanged()
+    );
+  }
+
+  /**
+   * Observable that emits true when the call can be resumed from hold
+   */
+  get canResume$(): Observable<boolean> {
+    return this.callState$.pipe(
+      map((state) => CallStateHelpers.canResume(state)),
+      distinctUntilChanged()
+    );
+  }
+
+  /**
+   * Answer the incoming call
+   */
+  async answer(): Promise<void> {
+    if (!CallStateHelpers.canAnswer(this.currentState)) {
+      throw new Error(`Cannot answer call in state: ${this.currentState}`);
+    }
+
+    try {
+      // On iOS, use CallKit coordinator for proper audio session handling
+      if (Platform.OS === 'ios') {
+        const { callKitCoordinator } = await import('../callkit/callkit-coordinator');
+        if (callKitCoordinator.isAvailable()) {
+          console.log('Call: Using CallKit coordinator to answer call (iOS)');
+          await callKitCoordinator.answerCallFromUI(this._telnyxCall);
+          return;
+        }
+      }
+
+      // Fallback for Android or when CallKit is not available
+      console.log('Call: Setting state to CONNECTING before answering');
+      this._callState.next(TelnyxCallState.CONNECTING);
+
+      await this._telnyxCall.answer();
+    } catch (error) {
+      console.error('Failed to answer call:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Hang up the call
+   */
+  async hangup(): Promise<void> {
+    if (!CallStateHelpers.canHangup(this.currentState)) {
+      throw new Error(`Cannot hang up call in state: ${this.currentState}`);
+    }
+
+    try {
+      // On iOS, use CallKit coordinator for proper CallKit cleanup
+      if (Platform.OS === 'ios') {
+        const { callKitCoordinator } = await import('../callkit/callkit-coordinator');
+        if (callKitCoordinator.isAvailable()) {
+          console.log('Call: Using CallKit coordinator to end call (iOS)');
+          await callKitCoordinator.endCallFromUI(this._telnyxCall);
+          return;
+        }
+      }
+
+      // Fallback for Android or when CallKit is not available
+      await this._telnyxCall.hangup();
+    } catch (error) {
+      console.error('Failed to hang up call:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Put the call on hold
+   */
+  async hold(): Promise<void> {
+    if (!CallStateHelpers.canHold(this.currentState)) {
+      throw new Error(`Cannot hold call in state: ${this.currentState}`);
+    }
+
+    try {
+      await this._telnyxCall.hold();
+    } catch (error) {
+      console.error('Failed to hold call:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Resume the call from hold
+   */
+  async resume(): Promise<void> {
+    if (!CallStateHelpers.canResume(this.currentState)) {
+      throw new Error(`Cannot resume call in state: ${this.currentState}`);
+    }
+
+    try {
+      await this._telnyxCall.unhold();
+    } catch (error) {
+      console.error('Failed to resume call:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Mute the call
+   */
+  async mute(): Promise<void> {
+    if (!CallStateHelpers.canToggleMute(this.currentState)) {
+      throw new Error(`Cannot mute call in state: ${this.currentState}`);
+    }
+
+    try {
+      this._telnyxCall.mute();
+      this._isMuted.next(true);
+    } catch (error) {
+      console.error('Failed to mute call:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Unmute the call
+   */
+  async unmute(): Promise<void> {
+    if (!CallStateHelpers.canToggleMute(this.currentState)) {
+      throw new Error(`Cannot unmute call in state: ${this.currentState}`);
+    }
+
+    try {
+      this._telnyxCall.unmute();
+      this._isMuted.next(false);
+    } catch (error) {
+      console.error('Failed to unmute call:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Toggle mute state
+   */
+  async toggleMute(): Promise<void> {
+    if (this.currentIsMuted) {
+      await this.unmute();
+    } else {
+      await this.mute();
+    }
+  }
+
+  /**
+   * Set the call to connecting state (used for push notification calls when answered via CallKit)
+   * @internal
+   */
+  setConnecting(): void {
+    console.log('Call: Setting state to CONNECTING for push notification answer');
+    this._callState.next(TelnyxCallState.CONNECTING);
+  }
+
+  /**
+   * Clean up resources when the call is disposed
+   */
+  dispose(): void {
+    this._stopDurationTimer();
+    this._callState.complete();
+    this._isMuted.complete();
+    this._isHeld.complete();
+    this._duration.complete();
+  }
+
+  /**
+   * Set up listeners for the underlying Telnyx call
+   */
+  private _setupCallListeners(): void {
+    // Map Telnyx call states to our simplified states
+    this._telnyxCall.on('telnyx.call.state', (call: any, state: any) => {
+      const telnyxState = this._mapToTelnyxCallState(state);
+      this._callState.next(telnyxState);
+
+      // Start duration timer when call becomes active
+      if (telnyxState === TelnyxCallState.ACTIVE && !this._startTime) {
+        this._startDurationTimer();
+      }
+
+      // Stop duration timer when call ends
+      if (CallStateHelpers.isTerminated(telnyxState)) {
+        this._stopDurationTimer();
+      }
+    });
+  }
+
+  /**
+   * Map Telnyx SDK call states to our simplified call states
+   */
+  private _mapToTelnyxCallState(telnyxState: any): TelnyxCallState {
+    // This mapping will depend on the actual Telnyx SDK call states
+    // For now, using a basic mapping - this should be updated based on actual SDK
+    switch (telnyxState) {
+      case 'ringing':
+      case 'new':
+        return TelnyxCallState.RINGING;
+      case 'active':
+      case 'answered':
+        return TelnyxCallState.ACTIVE;
+      case 'held':
+        return TelnyxCallState.HELD;
+      case 'ended':
+      case 'hangup':
+        return TelnyxCallState.ENDED;
+      case 'failed':
+      case 'rejected':
+        return TelnyxCallState.FAILED;
+      default:
+        console.warn(`Unknown call state: ${telnyxState}`);
+        return TelnyxCallState.RINGING;
+    }
+  }
+
+  /**
+   * Start the duration timer
+   */
+  private _startDurationTimer(): void {
+    this._startTime = new Date();
+    this._durationTimer = setInterval(() => {
+      if (this._startTime) {
+        const duration = Math.floor((Date.now() - this._startTime.getTime()) / 1000);
+        this._duration.next(duration);
+      }
+    }, 1000);
+  }
+
+  /**
+   * Stop the duration timer
+   */
+  private _stopDurationTimer(): void {
+    if (this._durationTimer) {
+      clearInterval(this._durationTimer);
+      this._durationTimer = undefined;
+    }
+  }
+}

package/src/models/config.ts

@@ -0,0 +1,125 @@
+/**
+ * Configuration for credential-based authentication
+ */
+export interface CredentialConfig {
+  type: 'credential';
+  sipUser: string;
+  sipPassword: string;
+  debug?: boolean;
+  pushNotificationDeviceToken?: string;
+}
+
+/**
+ * Configuration for token-based authentication
+ */
+export interface TokenConfig {
+  type: 'token';
+  token: string;
+  debug?: boolean;
+  pushNotificationDeviceToken?: string;
+}
+
+/**
+ * Union type for all supported authentication configurations
+ */
+export type Config = CredentialConfig | TokenConfig;
+
+/**
+ * Type guard to check if config is credential-based
+ */
+export function isCredentialConfig(config: Config): config is CredentialConfig {
+  return config.type === 'credential';
+}
+
+/**
+ * Type guard to check if config is token-based
+ */
+export function isTokenConfig(config: Config): config is TokenConfig {
+  return config.type === 'token';
+}
+
+/**
+ * Validates a credential configuration
+ */
+export function validateCredentialConfig(config: CredentialConfig): string[] {
+  const errors: string[] = [];
+
+  if (!config.sipUser || config.sipUser.trim() === '') {
+    errors.push('sipUser is required');
+  }
+
+  if (!config.sipPassword || config.sipPassword.trim() === '') {
+    errors.push('sipPassword is required');
+  }
+
+  return errors;
+}
+
+/**
+ * Validates a token configuration
+ */
+export function validateTokenConfig(config: TokenConfig): string[] {
+  const errors: string[] = [];
+
+  if (!config.token || config.token.trim() === '') {
+    errors.push('token is required');
+  }
+
+  return errors;
+}
+
+/**
+ * Validates any configuration
+ */
+export function validateConfig(config: Config): string[] {
+  if (isCredentialConfig(config)) {
+    return validateCredentialConfig(config);
+  } else if (isTokenConfig(config)) {
+    return validateTokenConfig(config);
+  } else {
+    return ['Invalid configuration type'];
+  }
+}
+
+/**
+ * Creates a credential configuration
+ *
+ * @param sipUser - SIP username for authentication
+ * @param sipPassword - SIP password for authentication
+ * @param options - Optional configuration settings
+ * @param options.debug - Enable debug logging (sets SDK logLevel to 'debug')
+ * @param options.pushNotificationDeviceToken - Device token for push notifications
+ * @returns Complete credential configuration object
+ */
+export function createCredentialConfig(
+  sipUser: string,
+  sipPassword: string,
+  options?: Partial<Omit<CredentialConfig, 'type' | 'sipUser' | 'sipPassword'>>
+): CredentialConfig {
+  return {
+    type: 'credential',
+    sipUser,
+    sipPassword,
+    ...options,
+  };
+}
+
+/**
+ * Creates a token-based configuration
+ *
+ * @param sipToken - JWT token for authentication
+ * @param options - Optional configuration settings
+ * @param options.debug - Enable debug logging (sets SDK logLevel to 'debug')
+ * @param options.pushNotificationDeviceToken - Device token for push notifications
+ * @returns Complete token configuration object
+ */
+export function createTokenConfig(
+  sipToken: string,
+  options?: Partial<Omit<TokenConfig, 'type' | 'sipToken'>>
+): TokenConfig {
+  return {
+    type: 'token',
+    token: sipToken,
+    ...options,
+  };
+}

package/src/models/connection-state.ts

@@ -0,0 +1,50 @@
+/**
+ * Represents the connection state to the Telnyx platform.
+ *
+ * This enum provides a simplified view of the connection status,
+ * abstracting away the complexity of the underlying WebSocket states.
+ */
+export enum TelnyxConnectionState {
+  /** Initial state before any connection attempt */
+  DISCONNECTED = 'DISCONNECTED',
+
+  /** Attempting to establish connection */
+  CONNECTING = 'CONNECTING',
+
+  /** Successfully connected and authenticated */
+  CONNECTED = 'CONNECTED',
+
+  /** Connection lost, attempting to reconnect */
+  RECONNECTING = 'RECONNECTING',
+
+  /** Connection failed or authentication error */
+  ERROR = 'ERROR',
+}
+
+/**
+ * Type guard to check if a value is a valid TelnyxConnectionState
+ */
+export function isTelnyxConnectionState(value: any): value is TelnyxConnectionState {
+  return Object.values(TelnyxConnectionState).includes(value);
+}
+
+/**
+ * Helper function to determine if the connection state allows making calls
+ */
+export function canMakeCalls(state: TelnyxConnectionState): boolean {
+  return state === TelnyxConnectionState.CONNECTED;
+}
+
+/**
+ * Helper function to determine if the connection state indicates an active connection
+ */
+export function isConnected(state: TelnyxConnectionState): boolean {
+  return state === TelnyxConnectionState.CONNECTED;
+}
+
+/**
+ * Helper function to determine if the connection is in a transitional state
+ */
+export function isTransitioning(state: TelnyxConnectionState): boolean {
+  return state === TelnyxConnectionState.CONNECTING || state === TelnyxConnectionState.RECONNECTING;
+}