expo-callkit-telecom 0.1.0

package/ios/Stores/CallStore.swift

@@ -0,0 +1,149 @@
+import Collections
+import Foundation
+
+/// Thread-safe store for active call sessions.
+actor CallStore {
+  private var sessions: OrderedDictionary<UUID, CallSession> = [:]
+
+  private struct SessionObserver: Sendable {
+    let continuation: AsyncStream<CallSession>.Continuation
+    let filter: @Sendable (CallSession) -> Bool
+  }
+  private var sessionObservers: [UUID: [UUID: SessionObserver]] = [:]
+
+  /// The first session, if any.
+  var firstSession: CallSession? {
+    sessions.values.first
+  }
+
+  /// All sessions in insertion order.
+  var allSessions: [CallSession] {
+    Array(sessions.values)
+  }
+
+  /// Get a session by its system call ID.
+  func session(for id: UUID) -> CallSession? {
+    sessions[id]
+  }
+
+  /// Add a new session. No-op if session with same ID already exists.
+  func add(_ session: CallSession) {
+    guard sessions[session.id] == nil else { return }
+    sessions[session.id] = session
+    Task { @MainActor in
+      CallEventEmitter.shared.send(CallSessionAddedEvent(session: session))
+    }
+  }
+
+  /// Remove a session by its system call ID. No-op if session doesn't exist.
+  func remove(for id: UUID) {
+    guard sessions.removeValue(forKey: id) != nil else { return }
+    Task { @MainActor in
+      CallEventEmitter.shared.send(CallSessionRemovedEvent(id: id))
+    }
+  }
+
+  /// Remove all sessions.
+  func removeAll() {
+    let ids = Array(sessions.keys)
+    sessions.removeAll()
+    Task { @MainActor in
+      for id in ids {
+        CallEventEmitter.shared.send(CallSessionRemovedEvent(id: id))
+      }
+    }
+  }
+
+  // MARK: - Updates
+
+  /// Update a session using a closure.
+  /// Only sends update events if the session actually changed.
+  func update(for id: UUID, _ transform: (inout CallSession) -> Void) {
+    guard var session = sessions[id] else { return }
+    let previousSession = session
+    transform(&session)
+
+    // Skip if nothing changed
+    guard session != previousSession else { return }
+
+    sessions[id] = session
+
+    // Notify observers whose filter matches
+    sessionObservers[id]?.values.forEach { observer in
+      if observer.filter(session) {
+        observer.continuation.yield(session)
+      }
+    }
+
+    Task { @MainActor in
+      CallEventEmitter.shared.send(CallSessionUpdatedEvent(session: session))
+    }
+  }
+
+  /// Update the status of a session.
+  func updateStatus(for id: UUID, status: CallSession.Status) {
+    update(for: id) { session in
+      session.status = status
+    }
+  }
+
+  /// Update the connectedAt timestamp of a session.
+  func updateConnectedAt(for id: UUID, connectedAt: Date?) {
+    update(for: id) { session in
+      session.connectedAt = connectedAt
+    }
+  }
+
+  /// Update the muted state of a session.
+  func updateMuted(for id: UUID, isMuted: Bool) {
+    update(for: id) { session in
+      session.isMuted = isMuted
+    }
+  }
+
+  /// Update the held state of a session.
+  func updateHeld(for id: UUID, isOnHold: Bool) {
+    update(for: id) { session in
+      session.isOnHold = isOnHold
+    }
+  }
+
+  // MARK: - Session Observation
+
+  /// Returns an AsyncStream that emits session updates matching the filter.
+  /// Immediately emits the current session if it exists and matches the filter.
+  func sessionUpdates(
+    for callId: UUID,
+    where filter: @escaping @Sendable (CallSession) -> Bool = { _ in true }
+  ) -> AsyncStream<CallSession> {
+    AsyncStream { continuation in
+      let observerId = UUID()
+
+      // Emit current session if it matches
+      if let session = sessions[callId], filter(session) {
+        continuation.yield(session)
+      }
+
+      // Register observer
+      if sessionObservers[callId] == nil {
+        sessionObservers[callId] = [:]
+      }
+      sessionObservers[callId]?[observerId] = SessionObserver(
+        continuation: continuation,
+        filter: filter
+      )
+
+      continuation.onTermination = { @Sendable [weak self] _ in
+        guard let self else { return }
+        Task { await self.removeSessionObserver(callId: callId, observerId: observerId) }
+      }
+    }
+  }
+
+  private func removeSessionObserver(callId: UUID, observerId: UUID) {
+    sessionObservers[callId]?[observerId] = nil
+    if sessionObservers[callId]?.isEmpty == true {
+      sessionObservers[callId] = nil
+    }
+  }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "expo-callkit-telecom",
+  "version": "0.1.0",
+  "description": "Expo module wrapping CallKit (iOS) and Jetpack Core-Telecom (Android) with API parity",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build && expo-module build plugin",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p plugin",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/client/ios",
+    "open:android": "open -a \"Android Studio\" example/client/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "callkit",
+    "telecom",
+    "voip",
+    "calling",
+    "webrtc"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mfairley/expo-callkit-telecom.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mfairley/expo-callkit-telecom/issues"
+  },
+  "author": {
+    "name": "Michael Fairley",
+    "url": "https://github.com/mfairley"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/mfairley/expo-callkit-telecom#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.2.14",
+    "expo-module-scripts": "^55.0.2",
+    "expo": "^55.0.24",
+    "react": "19.2.0",
+    "react-native": "0.83.6"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*",
+    "expo-notifications": "*",
+    "@livekit/react-native-webrtc": ">=144.0.0"
+  }
+}

package/plugin/build/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_INCOMING_CALL_TIMEOUT = 45;
+export declare const DEFAULT_OUTGOING_CALL_TIMEOUT = 60;
+export declare const DEFAULT_FULFILL_ANSWER_CALL_TIMEOUT = 30;

package/plugin/build/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FULFILL_ANSWER_CALL_TIMEOUT = exports.DEFAULT_OUTGOING_CALL_TIMEOUT = exports.DEFAULT_INCOMING_CALL_TIMEOUT = void 0;
+// Default timeout values in seconds
+exports.DEFAULT_INCOMING_CALL_TIMEOUT = 45;
+exports.DEFAULT_OUTGOING_CALL_TIMEOUT = 60;
+exports.DEFAULT_FULFILL_ANSWER_CALL_TIMEOUT = 30;

package/plugin/build/withExpoCallKitTelecom.d.ts

@@ -0,0 +1,67 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+export type ExpoCallKitTelecomPluginProps = {
+    /**
+     * Custom message for microphone permission prompt. Set to false to skip.
+     * @platform ios
+     */
+    microphonePermission?: string | false;
+    /**
+     * Custom message for camera permission prompt. Set to false to skip.
+     * @platform ios
+     */
+    cameraPermission?: string | false;
+    /**
+     * Timeout in seconds for incoming calls before they are marked as unanswered.
+     * @default 45
+     * @platform ios
+     * @platform android
+     */
+    incomingCallTimeout?: number;
+    /**
+     * Timeout in seconds for outgoing calls to connect before they are marked as unanswered.
+     * @default 60
+     * @platform ios
+     * @platform android
+     */
+    outgoingCallTimeout?: number;
+    /**
+     * Timeout in seconds for waiting for the call to connect after answering.
+     * @default 30
+     * @platform ios
+     * @platform android
+     */
+    fulfillAnswerCallTimeout?: number;
+    /**
+     * Array of sound file paths (relative to project root) to include in the app.
+     * These files will be copied into the iOS bundle and Android raw resources.
+     * Supported formats: .caf, .aiff, .wav (max 30 seconds for CallKit ringtones).
+     * @platform ios
+     * @platform android
+     */
+    sounds?: string[];
+    /**
+     * The default ringtone for incoming calls on iOS (CallKit).
+     * Can be the filename (with extension) of one of the provided sounds,
+     * or 'default' to use the system ringtone.
+     * @default 'default'
+     * @platform ios
+     */
+    defaultRingtoneIos?: string;
+    /**
+     * The default ringtone for incoming calls on Android (notification channel).
+     * Can be the filename (with extension) of one of the provided sounds,
+     * or 'default' to use the system ringtone.
+     * @default 'default'
+     * @platform android
+     */
+    defaultRingtoneAndroid?: string;
+    /**
+     * The default dialtone to play during outgoing calls while connecting.
+     * Must be the filename (with extension) of one of the provided sounds.
+     * @platform ios
+     * @platform android
+     */
+    defaultDialtone?: string;
+};
+declare const _default: ConfigPlugin<void | ExpoCallKitTelecomPluginProps>;
+export default _default;

package/plugin/build/withExpoCallKitTelecom.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("expo/config-plugins");
+const package_json_1 = __importDefault(require("../../package.json"));
+const withExpoCallKitTelecomAndroid_1 = require("./withExpoCallKitTelecomAndroid");
+const withExpoCallKitTelecomIos_1 = require("./withExpoCallKitTelecomIos");
+const withExpoCallKitTelecom = (config, props) => {
+    const opts = props ?? {};
+    config = (0, withExpoCallKitTelecomAndroid_1.withExpoCallKitTelecomAndroid)(config, opts);
+    config = (0, withExpoCallKitTelecomIos_1.withExpoCallKitTelecomIos)(config, opts);
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withExpoCallKitTelecom, package_json_1.default.name, package_json_1.default.version);

package/plugin/build/withExpoCallKitTelecomAndroid.d.ts

@@ -0,0 +1,3 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+import type { ExpoCallKitTelecomPluginProps } from "./withExpoCallKitTelecom";
+export declare const withExpoCallKitTelecomAndroid: ConfigPlugin<ExpoCallKitTelecomPluginProps>;

package/plugin/build/withExpoCallKitTelecomAndroid.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withExpoCallKitTelecomAndroid = void 0;
+const config_plugins_1 = require("expo/config-plugins");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("./constants");
+const ERROR_MSG_PREFIX = "An error occurred while configuring Android calls. ";
+// biome-ignore lint/suspicious/noExplicitAny: Expo config plugin manifest types are untyped
+function setMetaDataValue(app, key, value) {
+    const existing = app["meta-data"]?.find(
+    // biome-ignore lint/suspicious/noExplicitAny: manifest meta-data items are untyped
+    (item) => item.$["android:name"] === key);
+    if (existing) {
+        existing.$["android:value"] = value;
+        return;
+    }
+    if (!app["meta-data"]) {
+        app["meta-data"] = [];
+    }
+    app["meta-data"].push({
+        $: {
+            "android:name": key,
+            "android:value": value,
+        },
+    });
+}
+/**
+ * Sanitizes a filename for use as an Android raw resource name.
+ *
+ * Android raw resource names must be lowercase, alphanumeric + underscores,
+ * and cannot start with a digit.
+ */
+function toAndroidRawResourceName(filename) {
+    const withoutExtension = filename.replace(/\.[^.]+$/, "");
+    const sanitized = withoutExtension.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+    return /^\d/.test(sanitized) ? `_${sanitized}` : sanitized;
+}
+/**
+ * Configures call timeout values in AndroidManifest metadata.
+ */
+const withTimeouts = (config, { incomingCallTimeout, outgoingCallTimeout, fulfillAnswerCallTimeout }) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const app = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
+        setMetaDataValue(app, "ExpoCallKitTelecomIncomingCallTimeout", String(incomingCallTimeout ?? constants_1.DEFAULT_INCOMING_CALL_TIMEOUT));
+        setMetaDataValue(app, "ExpoCallKitTelecomOutgoingCallTimeout", String(outgoingCallTimeout ?? constants_1.DEFAULT_OUTGOING_CALL_TIMEOUT));
+        setMetaDataValue(app, "ExpoCallKitTelecomFulfillAnswerCallTimeout", String(fulfillAnswerCallTimeout ?? constants_1.DEFAULT_FULFILL_ANSWER_CALL_TIMEOUT));
+        return config;
+    });
+};
+/**
+ * Copies sound files into the Android raw resources directory.
+ */
+const withSounds = (config, { sounds }) => {
+    if (!sounds || sounds.length === 0) {
+        return config;
+    }
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        "android",
+        (config) => {
+            const projectRoot = config.modRequest.projectRoot;
+            const rawDir = (0, path_1.resolve)(projectRoot, "android", "app", "src", "main", "res", "raw");
+            (0, fs_1.mkdirSync)(rawDir, { recursive: true });
+            for (const soundPath of sounds) {
+                const filename = (0, path_1.basename)(soundPath);
+                const sourcePath = (0, path_1.resolve)(projectRoot, soundPath);
+                if (!(0, fs_1.existsSync)(sourcePath)) {
+                    throw new Error(`${ERROR_MSG_PREFIX}Sound file not found: ${sourcePath}`);
+                }
+                const resourceName = toAndroidRawResourceName(filename);
+                const extension = filename.includes(".")
+                    ? filename.substring(filename.lastIndexOf("."))
+                    : "";
+                const destinationPath = (0, path_1.resolve)(rawDir, `${resourceName}${extension}`);
+                (0, fs_1.copyFileSync)(sourcePath, destinationPath);
+            }
+            return config;
+        },
+    ]);
+};
+/**
+ * Configures the default dialtone for outgoing calls in AndroidManifest metadata.
+ */
+const withDefaultDialtone = (config, { sounds, defaultDialtone }) => {
+    if (!defaultDialtone) {
+        return config;
+    }
+    const soundFilenames = sounds?.map((s) => (0, path_1.basename)(s)) ?? [];
+    if (soundFilenames.length === 0) {
+        throw new Error(`${ERROR_MSG_PREFIX}"defaultDialtone" was specified but no ` +
+            `sounds were provided.`);
+    }
+    if (!soundFilenames.includes(defaultDialtone)) {
+        throw new Error(`${ERROR_MSG_PREFIX}"defaultDialtone" must be one of the provided ` +
+            `sounds (${soundFilenames.join(", ")}).`);
+    }
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const app = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
+        setMetaDataValue(app, "ExpoCallKitTelecomDefaultDialtone", toAndroidRawResourceName(defaultDialtone));
+        return config;
+    });
+};
+/**
+ * Configures the default ringtone for incoming calls in AndroidManifest metadata.
+ *
+ * Mirrors the iOS `withDefaultRingtone` plugin. The Kotlin side reads
+ * `ExpoCallKitTelecomDefaultRingtone` from manifest metadata and sets it as the
+ * notification channel sound.
+ */
+const withDefaultRingtone = (config, { sounds, defaultRingtone }) => {
+    if (!defaultRingtone || defaultRingtone === "default") {
+        return config;
+    }
+    const soundFilenames = sounds?.map((s) => (0, path_1.basename)(s)) ?? [];
+    if (soundFilenames.length === 0) {
+        throw new Error(`${ERROR_MSG_PREFIX}"defaultRingtone" was specified but no ` +
+            `sounds were provided.`);
+    }
+    if (!soundFilenames.includes(defaultRingtone)) {
+        throw new Error(`${ERROR_MSG_PREFIX}"defaultRingtone" must be one of the provided ` +
+            `sounds (${soundFilenames.join(", ")}) or "default" for ` +
+            `system ringtone.`);
+    }
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const app = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
+        setMetaDataValue(app, "ExpoCallKitTelecomDefaultRingtone", toAndroidRawResourceName(defaultRingtone));
+        return config;
+    });
+};
+/**
+ * Removes expo-notifications' ExpoFirebaseMessagingService from the manifest.
+ *
+ * Our ExpoCallKitTelecomMessagingService extends it and takes over as the sole
+ * MESSAGING_EVENT handler, delegating non-call messages via super.
+ * Having both services registered would cause undefined delivery behaviour.
+ *
+ * The service is declared in expo-notifications' library AndroidManifest.xml,
+ * so we must use `tools:node="remove"` to tell the manifest merger to strip it.
+ */
+const withFirebaseMessagingService = (config) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const manifest = config.modResults.manifest;
+        // Ensure the tools namespace is declared on the root <manifest> element.
+        if (!manifest.$["xmlns:tools"]) {
+            manifest.$["xmlns:tools"] = "http://schemas.android.com/tools";
+        }
+        const app = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
+        if (!app.service) {
+            app.service = [];
+        }
+        const notificationsService = "expo.modules.notifications.service.ExpoFirebaseMessagingService";
+        // Remove any existing entry first (idempotent across repeated prebuilds).
+        app.service = app.service.filter((service) => service.$?.["android:name"] !== notificationsService);
+        // Add a tools:node="remove" marker so the manifest merger strips the
+        // library-declared service during the Gradle build.
+        const removeEntry = {
+            $: {
+                "android:name": notificationsService,
+                "tools:node": "remove",
+            },
+        };
+        app.service.push(removeEntry);
+        return config;
+    });
+};
+const withExpoCallKitTelecomAndroid = (config, props) => {
+    config = withTimeouts(config, props);
+    config = withSounds(config, props);
+    config = withDefaultRingtone(config, {
+        sounds: props.sounds,
+        defaultRingtone: props.defaultRingtoneAndroid,
+    });
+    config = withDefaultDialtone(config, props);
+    config = withFirebaseMessagingService(config, props);
+    return config;
+};
+exports.withExpoCallKitTelecomAndroid = withExpoCallKitTelecomAndroid;

package/plugin/build/withExpoCallKitTelecomIos.d.ts

@@ -0,0 +1,3 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+import type { ExpoCallKitTelecomPluginProps } from "./withExpoCallKitTelecom";
+export declare const withExpoCallKitTelecomIos: ConfigPlugin<ExpoCallKitTelecomPluginProps>;

package/plugin/build/withExpoCallKitTelecomIos.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withExpoCallKitTelecomIos = void 0;
+const config_plugins_1 = require("expo/config-plugins");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("./constants");
+const ERROR_MSG_PREFIX = "An error occurred while configuring iOS calls. ";
+// Default permission messages
+const CAMERA_USAGE = "Allow $(PRODUCT_NAME) to access your camera";
+const MICROPHONE_USAGE = "Allow $(PRODUCT_NAME) to access your microphone";
+// Required background modes for CallKit and PushKit:
+// - voip: Receive VoIP push notifications to wake the app for incoming calls
+// - audio: Continue audio playback/recording during calls when app is backgrounded
+const BACKGROUND_MODES = ["voip", "audio"];
+// SiriKit intents for voice-activated calls
+// INStartCallIntent: Unified intent for iOS 13+ (recommended)
+// INStartAudioCallIntent/INStartVideoCallIntent: Deprecated in iOS 13, but still
+// sent by the system in some cases (e.g., redialing from call history)
+const SIRI_INTENTS = [
+    "INStartCallIntent",
+    "INStartAudioCallIntent",
+    "INStartVideoCallIntent",
+];
+/**
+ * Configures camera and microphone permissions for VoIP and video calls.
+ */
+const withPermissions = (config, { cameraPermission, microphonePermission }) => {
+    return config_plugins_1.IOSConfig.Permissions.createPermissionsPlugin({
+        NSCameraUsageDescription: CAMERA_USAGE,
+        NSMicrophoneUsageDescription: MICROPHONE_USAGE,
+    })(config, {
+        NSCameraUsageDescription: cameraPermission,
+        NSMicrophoneUsageDescription: microphonePermission,
+    });
+};
+/**
+ * Configures push notification entitlement for PushKit VoIP notifications.
+ */
+const withPushNotificationEntitlement = (config) => {
+    return (0, config_plugins_1.withEntitlementsPlist)(config, (config) => {
+        const key = "aps-environment";
+        // Only set if not already configured; production builds use provisioning profile value
+        if (!config.modResults[key]) {
+            config.modResults[key] = "development";
+        }
+        return config;
+    });
+};
+/**
+ * Configures UIBackgroundModes for VoIP call handling.
+ */
+const withBackgroundModes = (config) => {
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        const existingModes = config.modResults.UIBackgroundModes;
+        const modes = Array.isArray(existingModes)
+            ? existingModes
+            : [];
+        const newModes = new Set([...modes, ...BACKGROUND_MODES]);
+        config.modResults.UIBackgroundModes = [...newModes];
+        return config;
+    });
+};
+/**
+ * Configures SiriKit intents for voice-activated audio/video calls.
+ */
+const withSiriIntents = (config) => {
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        const existingIntents = config.modResults.NSUserActivityTypes;
+        const intents = Array.isArray(existingIntents)
+            ? existingIntents
+            : [];
+        const newIntents = new Set([...intents, ...SIRI_INTENTS]);
+        config.modResults.NSUserActivityTypes = [...newIntents];
+        return config;
+    });
+};
+/**
+ * Configures call timeout values in Info.plist.
+ */
+const withTimeouts = (config, { incomingCallTimeout, outgoingCallTimeout, fulfillAnswerCallTimeout }) => {
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        config.modResults.ExpoCallKitTelecomIncomingCallTimeout =
+            incomingCallTimeout ?? constants_1.DEFAULT_INCOMING_CALL_TIMEOUT;
+        config.modResults.ExpoCallKitTelecomOutgoingCallTimeout =
+            outgoingCallTimeout ?? constants_1.DEFAULT_OUTGOING_CALL_TIMEOUT;
+        config.modResults.ExpoCallKitTelecomFulfillAnswerCallTimeout =
+            fulfillAnswerCallTimeout ?? constants_1.DEFAULT_FULFILL_ANSWER_CALL_TIMEOUT;
+        return config;
+    });
+};
+/**
+ * Copies sound files into the iOS project bundle.
+ */
+function setSoundFiles(config, sounds) {
+    const projectRoot = config.modRequest.projectRoot;
+    const projectName = config.modRequest.projectName;
+    if (!projectName) {
+        throw new Error(`${ERROR_MSG_PREFIX}Unable to find iOS project name.`);
+    }
+    const sourceRoot = (0, path_1.resolve)(projectRoot, "ios", projectName);
+    for (const soundPath of sounds) {
+        const filename = (0, path_1.basename)(soundPath);
+        const sourcePath = (0, path_1.resolve)(projectRoot, soundPath);
+        const destinationPath = (0, path_1.resolve)(sourceRoot, filename);
+        if (!(0, fs_1.existsSync)(sourcePath)) {
+            throw new Error(`${ERROR_MSG_PREFIX}Sound file not found: ${sourcePath}`);
+        }
+        // Copy the file to the iOS project directory
+        (0, fs_1.copyFileSync)(sourcePath, destinationPath);
+        // Add the file to the Xcode project if not already present
+        if (!config.modResults.hasFile(`${projectName}/${filename}`)) {
+            config.modResults = config_plugins_1.IOSConfig.XcodeUtils.addResourceFileToGroup({
+                filepath: `${projectName}/${filename}`,
+                groupName: projectName,
+                isBuildFile: true,
+                project: config.modResults,
+            });
+        }
+    }
+    return config;
+}
+/**
+ * Copies sound files into the iOS project bundle.
+ */
+const withSounds = (config, { sounds }) => {
+    if (sounds && sounds.length > 0) {
+        config = (0, config_plugins_1.withXcodeProject)(config, (config) => {
+            return setSoundFiles(config, sounds);
+        });
+    }
+    return config;
+};
+/**
+ * Configures the default ringtone for incoming calls in Info.plist.
+ */
+const withDefaultRingtone = (config, { sounds, defaultRingtone }) => {
+    const soundFilenames = sounds?.map((s) => (0, path_1.basename)(s)) ?? [];
+    // Validate defaultRingtone if specified and not 'default'
+    if (defaultRingtone && defaultRingtone !== "default") {
+        if (soundFilenames.length === 0) {
+            throw new Error(`${ERROR_MSG_PREFIX}"defaultRingtone" was specified but no ` +
+                `sounds were provided.`);
+        }
+        if (!soundFilenames.includes(defaultRingtone)) {
+            throw new Error(`${ERROR_MSG_PREFIX}"defaultRingtone" must be one of the provided ` +
+                `sounds (${soundFilenames.join(", ")}) or "default" for ` +
+                `system ringtone.`);
+        }
+    }
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        config.modResults.ExpoCallKitTelecomDefaultRingtone = defaultRingtone || "default";
+        return config;
+    });
+};
+/**
+ * Configures the default dialtone for outgoing calls in Info.plist.
+ */
+const withDefaultDialtone = (config, { sounds, defaultDialtone }) => {
+    if (!defaultDialtone) {
+        return config;
+    }
+    const soundFilenames = sounds?.map((s) => (0, path_1.basename)(s)) ?? [];
+    if (soundFilenames.length === 0) {
+        throw new Error(`${ERROR_MSG_PREFIX}"defaultDialtone" was specified but no ` +
+            `sounds were provided.`);
+    }
+    if (!soundFilenames.includes(defaultDialtone)) {
+        throw new Error(`${ERROR_MSG_PREFIX}"defaultDialtone" must be one of the provided ` +
+            `sounds (${soundFilenames.join(", ")}).`);
+    }
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        config.modResults.ExpoCallKitTelecomDefaultDialtone = defaultDialtone;
+        return config;
+    });
+};
+const withExpoCallKitTelecomIos = (config, { cameraPermission, microphonePermission, incomingCallTimeout, outgoingCallTimeout, fulfillAnswerCallTimeout, sounds, defaultRingtoneIos, defaultDialtone, }) => {
+    config = withPermissions(config, { cameraPermission, microphonePermission });
+    config = withPushNotificationEntitlement(config);
+    config = withBackgroundModes(config);
+    config = withSiriIntents(config);
+    config = withTimeouts(config, {
+        incomingCallTimeout,
+        outgoingCallTimeout,
+        fulfillAnswerCallTimeout,
+    });
+    config = withSounds(config, { sounds });
+    config = withDefaultRingtone(config, {
+        sounds,
+        defaultRingtone: defaultRingtoneIos,
+    });
+    config = withDefaultDialtone(config, { sounds, defaultDialtone });
+    return config;
+};
+exports.withExpoCallKitTelecomIos = withExpoCallKitTelecomIos;