@telnyx/react-voice-commons-sdk 0.1.0

package/lib/callkit/callkit.d.ts

@@ -0,0 +1,49 @@
+export declare enum CallEndReason {
+    Failed = 1,
+    RemoteEnded = 2,
+    Unanswered = 3,
+    AnsweredElsewhere = 4,
+    DeclinedElsewhere = 5
+}
+export interface CallKitEvent {
+    callUUID: string;
+    [key: string]: any;
+}
+declare class CallKitManager {
+    private bridge;
+    private eventEmitter;
+    private listeners;
+    /**
+     * Normalize UUID to lowercase for consistent handling in React Native
+     * iOS CallKit provides UUIDs in uppercase, but we want to use lowercase throughout React Native
+     */
+    private normalizeUUID;
+    /**
+     * Denormalize UUID back to uppercase for iOS CallKit bridge calls
+     * iOS CallKit expects UUIDs in uppercase format
+     */
+    private denormalizeUUID;
+    /**
+     * Normalize event object by converting callUUID to lowercase
+     */
+    private normalizeEvent;
+    constructor();
+    private setupEventListeners;
+    private notifyListeners;
+    startOutgoingCall(callUUID: string, handle: string, displayName: string): Promise<boolean>;
+    reportIncomingCall(callUUID: string, handle: string, displayName: string): Promise<boolean>;
+    answerCall(callUUID: string): Promise<boolean>;
+    endCall(callUUID: string): Promise<boolean>;
+    reportCallConnected(callUUID: string): Promise<boolean>;
+    reportCallEnded(callUUID: string, reason?: CallEndReason): Promise<boolean>;
+    updateCall(callUUID: string, displayName: string, handle: string): Promise<boolean>;
+    getActiveCalls(): Promise<any[]>;
+    onStartCall(listener: (event: CallKitEvent) => void): () => void;
+    onAnswerCall(listener: (event: CallKitEvent) => void): () => void;
+    onEndCall(listener: (event: CallKitEvent) => void): () => void;
+    onReceivePush(listener: (event: CallKitEvent) => void): () => void;
+    generateCallUUID(): string;
+    isAvailable(): boolean;
+}
+export declare const CallKit: CallKitManager;
+export default CallKit;

package/lib/callkit/callkit.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallKit = exports.CallEndReason = void 0;
+const react_native_1 = require("react-native");
+// Call end reasons
+var CallEndReason;
+(function (CallEndReason) {
+    CallEndReason[CallEndReason["Failed"] = 1] = "Failed";
+    CallEndReason[CallEndReason["RemoteEnded"] = 2] = "RemoteEnded";
+    CallEndReason[CallEndReason["Unanswered"] = 3] = "Unanswered";
+    CallEndReason[CallEndReason["AnsweredElsewhere"] = 4] = "AnsweredElsewhere";
+    CallEndReason[CallEndReason["DeclinedElsewhere"] = 5] = "DeclinedElsewhere";
+})(CallEndReason || (exports.CallEndReason = CallEndReason = {}));
+class CallKitManager {
+    /**
+     * Normalize UUID to lowercase for consistent handling in React Native
+     * iOS CallKit provides UUIDs in uppercase, but we want to use lowercase throughout React Native
+     */
+    normalizeUUID(uuid) {
+        return uuid.toLowerCase();
+    }
+    /**
+     * Denormalize UUID back to uppercase for iOS CallKit bridge calls
+     * iOS CallKit expects UUIDs in uppercase format
+     */
+    denormalizeUUID(uuid) {
+        return uuid.toUpperCase();
+    }
+    /**
+     * Normalize event object by converting callUUID to lowercase
+     */
+    normalizeEvent(event) {
+        return {
+            ...event,
+            callUUID: this.normalizeUUID(event.callUUID),
+        };
+    }
+    constructor() {
+        this.bridge = null;
+        this.eventEmitter = null;
+        this.listeners = new Map();
+        if (react_native_1.Platform.OS === 'ios') {
+            const { CallKitBridge } = react_native_1.NativeModules;
+            if (CallKitBridge) {
+                this.bridge = CallKitBridge;
+                this.eventEmitter = new react_native_1.NativeEventEmitter(CallKitBridge);
+                this.setupEventListeners();
+            }
+            else {
+                console.warn('CallKit: CallKitBridge not available');
+            }
+        }
+    }
+    setupEventListeners() {
+        if (!this.eventEmitter)
+            return;
+        // Listen for CallKit actions - normalize UUIDs to lowercase for React Native
+        this.eventEmitter.addListener('CallKitDidReceiveStartCallAction', (event) => {
+            const normalizedEvent = this.normalizeEvent(event);
+            console.log('CallKit: Received start call action', normalizedEvent);
+            this.notifyListeners('startCall', normalizedEvent);
+        });
+        this.eventEmitter.addListener('CallKitDidPerformAnswerCallAction', (event) => {
+            const normalizedEvent = this.normalizeEvent(event);
+            console.log('CallKit: Received answer call action', normalizedEvent);
+            this.notifyListeners('answerCall', normalizedEvent);
+        });
+        this.eventEmitter.addListener('CallKitDidPerformEndCallAction', (event) => {
+            const normalizedEvent = this.normalizeEvent(event);
+            console.log('CallKit: Received end call action', normalizedEvent);
+            this.notifyListeners('endCall', normalizedEvent);
+        });
+        this.eventEmitter.addListener('CallKitDidReceivePush', (event) => {
+            const normalizedEvent = this.normalizeEvent(event);
+            console.log('CallKit: Received push notification event', normalizedEvent);
+            this.notifyListeners('receivePush', normalizedEvent);
+        });
+    }
+    notifyListeners(eventType, event) {
+        const listener = this.listeners.get(eventType);
+        if (listener) {
+            listener(event);
+        }
+    }
+    // Public API methods
+    async startOutgoingCall(callUUID, handle, displayName) {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            console.warn('CallKit: Not available on this platform');
+            return false;
+        }
+        try {
+            // Convert to uppercase for iOS CallKit bridge
+            const uppercaseUUID = this.denormalizeUUID(callUUID);
+            console.log('CallKit: Starting outgoing call', {
+                callUUID: uppercaseUUID,
+                handle,
+                displayName,
+            });
+            const result = await this.bridge.startOutgoingCall(uppercaseUUID, handle, displayName);
+            console.log('CallKit: Outgoing call started successfully', result);
+            return result.success;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to start outgoing call', error);
+            return false;
+        }
+    }
+    async reportIncomingCall(callUUID, handle, displayName) {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            console.warn('CallKit: Not available on this platform');
+            return false;
+        }
+        try {
+            // Convert to uppercase for iOS CallKit bridge
+            const uppercaseUUID = this.denormalizeUUID(callUUID);
+            console.log('CallKit: Reporting incoming call', {
+                callUUID: uppercaseUUID,
+                handle,
+                displayName,
+            });
+            const result = await this.bridge.reportIncomingCall(uppercaseUUID, handle, displayName);
+            console.log('CallKit: Incoming call reported successfully', result);
+            return result.success;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to report incoming call', error);
+            return false;
+        }
+    }
+    async answerCall(callUUID) {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            console.warn('CallKit: Not available on this platform');
+            return false;
+        }
+        try {
+            // Convert to uppercase for iOS CallKit bridge
+            const uppercaseUUID = this.denormalizeUUID(callUUID);
+            console.log('CallKit: Answering call', { callUUID: uppercaseUUID });
+            const result = await this.bridge.answerCall(uppercaseUUID);
+            console.log('CallKit: Call answered successfully', result);
+            return result.success;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to answer call', error);
+            return false;
+        }
+    }
+    async endCall(callUUID) {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            console.warn('CallKit: Not available on this platform');
+            return false;
+        }
+        try {
+            // Convert to uppercase for iOS CallKit bridge
+            const uppercaseUUID = this.denormalizeUUID(callUUID);
+            console.log('CallKit: Ending call', { callUUID: uppercaseUUID });
+            const result = await this.bridge.endCall(uppercaseUUID);
+            console.log('CallKit: Call ended successfully', result);
+            return result.success;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to end call', error);
+            return false;
+        }
+    }
+    async reportCallConnected(callUUID) {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            return false;
+        }
+        try {
+            // Convert to uppercase for iOS CallKit bridge
+            const uppercaseUUID = this.denormalizeUUID(callUUID);
+            console.log('CallKit: Reporting call connected', { callUUID: uppercaseUUID });
+            const result = await this.bridge.reportCallConnected(uppercaseUUID);
+            console.log('CallKit: Call connected reported successfully', result);
+            return result.success;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to report call connected', error);
+            return false;
+        }
+    }
+    async reportCallEnded(callUUID, reason = CallEndReason.RemoteEnded) {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            return false;
+        }
+        try {
+            // Convert to uppercase for iOS CallKit bridge
+            const uppercaseUUID = this.denormalizeUUID(callUUID);
+            console.log('CallKit: Reporting call ended', { callUUID: uppercaseUUID, reason });
+            const result = await this.bridge.reportCallEnded(uppercaseUUID, reason);
+            console.log('CallKit: Call ended reported successfully', result);
+            return result.success;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to report call ended', error);
+            return false;
+        }
+    }
+    async updateCall(callUUID, displayName, handle) {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            return false;
+        }
+        try {
+            // Convert to uppercase for iOS CallKit bridge
+            const uppercaseUUID = this.denormalizeUUID(callUUID);
+            console.log('CallKit: Updating call', { callUUID: uppercaseUUID, displayName, handle });
+            const result = await this.bridge.updateCall(uppercaseUUID, displayName, handle);
+            console.log('CallKit: Call updated successfully', result);
+            return result.success;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to update call', error);
+            return false;
+        }
+    }
+    async getActiveCalls() {
+        if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+            return [];
+        }
+        try {
+            const calls = await this.bridge.getActiveCalls();
+            console.log('CallKit: Active calls retrieved', calls);
+            return calls;
+        }
+        catch (error) {
+            console.error('CallKit: Failed to get active calls', error);
+            return [];
+        }
+    }
+    // Event listener management
+    onStartCall(listener) {
+        this.listeners.set('startCall', listener);
+        return () => this.listeners.delete('startCall');
+    }
+    onAnswerCall(listener) {
+        this.listeners.set('answerCall', listener);
+        return () => this.listeners.delete('answerCall');
+    }
+    onEndCall(listener) {
+        this.listeners.set('endCall', listener);
+        return () => this.listeners.delete('endCall');
+    }
+    onReceivePush(listener) {
+        this.listeners.set('receivePush', listener);
+        return () => this.listeners.delete('receivePush');
+    }
+    // Utility methods
+    generateCallUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    isAvailable() {
+        return react_native_1.Platform.OS === 'ios' && this.bridge !== null;
+    }
+}
+// Export singleton instance
+exports.CallKit = new CallKitManager();
+exports.default = exports.CallKit;

package/lib/callkit/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CallKit, CallEndReason, type CallKitEvent } from './callkit';
+export { default as callKitCoordinator } from './callkit-coordinator';
+export { useCallKit } from './use-callkit';
+export { useCallKitCoordinator } from '../hooks/use-callkit-coordinator';

package/lib/callkit/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCallKitCoordinator = exports.useCallKit = exports.callKitCoordinator = exports.CallEndReason = exports.CallKit = void 0;
+var callkit_1 = require("./callkit");
+Object.defineProperty(exports, "CallKit", { enumerable: true, get: function () { return __importDefault(callkit_1).default; } });
+Object.defineProperty(exports, "CallEndReason", { enumerable: true, get: function () { return callkit_1.CallEndReason; } });
+var callkit_coordinator_1 = require("./callkit-coordinator");
+Object.defineProperty(exports, "callKitCoordinator", { enumerable: true, get: function () { return __importDefault(callkit_coordinator_1).default; } });
+var use_callkit_1 = require("./use-callkit");
+Object.defineProperty(exports, "useCallKit", { enumerable: true, get: function () { return use_callkit_1.useCallKit; } });
+var use_callkit_coordinator_1 = require("../hooks/use-callkit-coordinator");
+Object.defineProperty(exports, "useCallKitCoordinator", { enumerable: true, get: function () { return use_callkit_coordinator_1.useCallKitCoordinator; } });

package/lib/callkit/use-callkit-coordinator.d.ts

@@ -0,0 +1,21 @@
+import { Call } from '@telnyx/react-native-voice-sdk';
+import { TelnyxVoipClient } from '../telnyx-voip-client';
+export declare function useCallKitCoordinator(): {
+  reportIncomingCall: (
+    call: Call,
+    callerName: string,
+    callerNumber: string
+  ) => Promise<string | null>;
+  startOutgoingCall: (
+    call: Call,
+    destinationNumber: string,
+    displayName?: string
+  ) => Promise<string | null>;
+  answerCallFromUI: (call: Call) => Promise<boolean>;
+  endCallFromUI: (call: Call) => Promise<boolean>;
+  getCallKitUUID: (call: Call) => string | null;
+  getWebRTCCall: (callKitUUID: string) => Call | null;
+  linkExistingCallKitCall: (call: Call, callKitUUID: string) => void;
+  isAvailable: () => boolean;
+  setVoipClient: (voipClient: TelnyxVoipClient) => void;
+};

package/lib/callkit/use-callkit-coordinator.js

@@ -0,0 +1,53 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.useCallKitCoordinator = useCallKitCoordinator;
+const react_1 = require('react');
+const callkit_coordinator_1 = __importDefault(require('./callkit-coordinator'));
+function useCallKitCoordinator() {
+  const reportIncomingCall = (0, react_1.useCallback)(async (call, callerName, callerNumber) => {
+    return callkit_coordinator_1.default.reportIncomingCall(call, callerName, callerNumber);
+  }, []);
+  const startOutgoingCall = (0, react_1.useCallback)(
+    async (call, destinationNumber, displayName) => {
+      return callkit_coordinator_1.default.startOutgoingCall(call, destinationNumber, displayName);
+    },
+    []
+  );
+  const answerCallFromUI = (0, react_1.useCallback)(async (call) => {
+    return callkit_coordinator_1.default.answerCallFromUI(call);
+  }, []);
+  const endCallFromUI = (0, react_1.useCallback)(async (call) => {
+    return callkit_coordinator_1.default.endCallFromUI(call);
+  }, []);
+  const getCallKitUUID = (0, react_1.useCallback)((call) => {
+    return callkit_coordinator_1.default.getCallKitUUID(call);
+  }, []);
+  const getWebRTCCall = (0, react_1.useCallback)((callKitUUID) => {
+    return callkit_coordinator_1.default.getWebRTCCall(callKitUUID);
+  }, []);
+  const linkExistingCallKitCall = (0, react_1.useCallback)((call, callKitUUID) => {
+    callkit_coordinator_1.default.linkExistingCallKitCall(call, callKitUUID);
+  }, []);
+  const isAvailable = (0, react_1.useCallback)(() => {
+    return callkit_coordinator_1.default.isAvailable();
+  }, []);
+  const setVoipClient = (0, react_1.useCallback)((voipClient) => {
+    callkit_coordinator_1.default.setVoipClient(voipClient);
+  }, []);
+  return {
+    reportIncomingCall,
+    startOutgoingCall,
+    answerCallFromUI,
+    endCallFromUI,
+    getCallKitUUID,
+    getWebRTCCall,
+    linkExistingCallKitCall,
+    isAvailable,
+    setVoipClient,
+  };
+}

package/lib/callkit/use-callkit.d.ts

@@ -0,0 +1,28 @@
+import { Call } from '@telnyx/react-native-voice-sdk';
+import { CallEndReason } from './callkit';
+interface UseCallKitOptions {
+    onAnswerCall?: (callUUID: string) => void;
+    onEndCall?: (callUUID: string) => void;
+    onStartCall?: (callUUID: string) => void;
+}
+interface CallKitCall {
+    uuid: string;
+    handle: string;
+    displayName: string;
+    isActive: boolean;
+    direction: 'incoming' | 'outgoing';
+}
+export declare function useCallKit(options?: UseCallKitOptions): {
+    isAvailable: boolean;
+    activeCalls: CallKitCall[];
+    startOutgoingCall: (call: Call, handle?: string, displayName?: string) => Promise<string | null>;
+    reportIncomingCall: (call: Call, handle?: string, displayName?: string) => Promise<string | null>;
+    answerCall: (callUUID: string) => Promise<boolean>;
+    endCall: (callUUID: string, reason?: CallEndReason) => Promise<boolean>;
+    reportCallConnected: (callUUID: string) => Promise<boolean>;
+    updateCall: (callUUID: string, displayName: string, handle: string) => Promise<boolean>;
+    getCallKitUUID: (call: Call) => string | null;
+    integrateCall: (call: Call, direction: "incoming" | "outgoing") => Promise<string>;
+    generateCallUUID: () => string;
+};
+export {};