@mentra/bluetooth-sdk 0.1.0

package/ios/Source/utils/PhoneAudioMonitor.swift

@@ -0,0 +1,226 @@
+//
+//  PhoneAudioMonitor.swift
+//  AOS
+//
+//  Monitors iOS system audio playback state
+//
+//  Used to detect when the phone is playing audio (music, podcasts, etc.)
+//  so we can temporarily suspend the LC3 microphone on MentraLive glasses
+//  to avoid overloading the MCU when both A2DP output and LC3 mic input
+//  are active simultaneously.
+//
+//  This class mirrors the Android PhoneAudioMonitor.kt implementation.
+//
+
+import AVFoundation
+import Foundation
+
+/// Listener protocol for phone audio state changes
+protocol PhoneAudioMonitorListener: AnyObject {
+    func onPhoneAudioStateChanged(isPlaying: Bool)
+}
+
+/// Monitors system audio playback to detect when the phone is playing audio
+class PhoneAudioMonitor {
+    /// Singleton instance
+    private static var instance: PhoneAudioMonitor?
+
+    private weak var listener: PhoneAudioMonitorListener?
+    private var isMonitoring = false
+    private var lastKnownState = false
+
+    /// Track our own app's audio playback state
+    /// isOtherAudioPlaying only detects OTHER apps, not our own
+    private var ownAppAudioPlaying = false
+
+    // Polling timer for fallback detection
+    private var pollingTimer: Timer?
+    private let pollingIntervalSeconds: TimeInterval = 1.0
+
+    private init() {
+        Bridge.log("PhoneAudioMonitor: Initialized")
+    }
+
+    static func getInstance() -> PhoneAudioMonitor {
+        if instance == nil {
+            instance = PhoneAudioMonitor()
+        }
+        return instance!
+    }
+
+    /// Check if any audio is currently playing on the device (including our own app)
+    func isPlaying() -> Bool {
+        let session = AVAudioSession.sharedInstance()
+        // Combine: other apps playing OR our own app playing
+        return session.isOtherAudioPlaying || ownAppAudioPlaying
+    }
+
+    /// Notify the monitor that our own app started/stopped playing audio
+    /// Called from RN AudioPlaybackService via Bridge
+    func setOwnAppAudioPlaying(_ playing: Bool) {
+        guard ownAppAudioPlaying != playing else { return }
+
+        ownAppAudioPlaying = playing
+        Bridge.log("PhoneAudioMonitor: Own app audio -> \(playing ? "PLAYING" : "STOPPED")")
+
+        // Immediately notify listener if overall state changed
+        notifyIfStateChanged(isPlaying())
+    }
+
+    /// Start monitoring for phone audio playback changes
+    ///
+    /// - Parameter listener: Callback to receive audio state change notifications
+    func startMonitoring(listener: PhoneAudioMonitorListener) {
+        guard !isMonitoring else {
+            Bridge.log("PhoneAudioMonitor: Already monitoring")
+            return
+        }
+
+        self.listener = listener
+        lastKnownState = isPlaying()
+        isMonitoring = true
+
+        Bridge.log(
+            "PhoneAudioMonitor: Starting audio playback monitoring (initial state: \(lastKnownState ? "playing" : "not playing"))"
+        )
+
+        // Register for silenceSecondaryAudioHint notification
+        // This is fired when other apps start/stop playing audio
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleSilenceSecondaryAudioHint),
+            name: AVAudioSession.silenceSecondaryAudioHintNotification,
+            object: nil
+        )
+
+        // Also register for interruption notifications as a supplement
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAudioInterruption),
+            name: AVAudioSession.interruptionNotification,
+            object: nil
+        )
+
+        // Start polling as a fallback mechanism
+        // Some audio sources might not trigger notifications reliably
+        startPolling()
+    }
+
+    /// Stop monitoring for phone audio playback changes
+    func stopMonitoring() {
+        guard isMonitoring else {
+            Bridge.log("PhoneAudioMonitor: Not currently monitoring")
+            return
+        }
+
+        Bridge.log("PhoneAudioMonitor: Stopping audio playback monitoring")
+
+        NotificationCenter.default.removeObserver(
+            self,
+            name: AVAudioSession.silenceSecondaryAudioHintNotification,
+            object: nil
+        )
+
+        NotificationCenter.default.removeObserver(
+            self,
+            name: AVAudioSession.interruptionNotification,
+            object: nil
+        )
+
+        stopPolling()
+
+        listener = nil
+        isMonitoring = false
+    }
+
+    /// Handle silenceSecondaryAudioHint notification
+    @objc private func handleSilenceSecondaryAudioHint(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let typeValue = userInfo[AVAudioSessionSilenceSecondaryAudioHintTypeKey] as? UInt,
+              let type = AVAudioSession.SilenceSecondaryAudioHintType(rawValue: typeValue)
+        else {
+            return
+        }
+
+        let isPlaying: Bool
+        switch type {
+        case .begin:
+            // Another app started playing audio
+            isPlaying = true
+            Bridge.log("PhoneAudioMonitor: Received silenceSecondaryAudioHint - begin")
+        case .end:
+            // Another app stopped playing audio
+            isPlaying = false
+            Bridge.log("PhoneAudioMonitor: Received silenceSecondaryAudioHint - end")
+        @unknown default:
+            // Check actual state for unknown types
+            isPlaying = self.isPlaying()
+        }
+
+        notifyIfStateChanged(isPlaying)
+    }
+
+    /// Handle audio interruption notifications
+    @objc private func handleAudioInterruption(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
+              let type = AVAudioSession.InterruptionType(rawValue: typeValue)
+        else {
+            return
+        }
+
+        switch type {
+        case .began:
+            // Audio was interrupted (e.g., phone call, other app took audio focus)
+            Bridge.log("PhoneAudioMonitor: Audio interruption began")
+            // Don't necessarily mean audio is playing - check actual state
+            notifyIfStateChanged(isPlaying())
+        case .ended:
+            Bridge.log("PhoneAudioMonitor: Audio interruption ended")
+            // Small delay to let audio state settle
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+                guard let self = self else { return }
+                self.notifyIfStateChanged(self.isPlaying())
+            }
+        @unknown default:
+            break
+        }
+    }
+
+    /// Start polling isOtherAudioPlaying as a fallback mechanism
+    private func startPolling() {
+        pollingTimer = Timer.scheduledTimer(
+            withTimeInterval: pollingIntervalSeconds,
+            repeats: true
+        ) { [weak self] _ in
+            guard let self = self, self.isMonitoring else { return }
+
+            let currentState = self.isPlaying()
+            self.notifyIfStateChanged(currentState)
+        }
+    }
+
+    /// Stop the polling mechanism
+    private func stopPolling() {
+        pollingTimer?.invalidate()
+        pollingTimer = nil
+    }
+
+    /// Notify listener if state has changed
+    private func notifyIfStateChanged(_ isPlaying: Bool) {
+        guard isPlaying != lastKnownState else { return }
+
+        lastKnownState = isPlaying
+        Bridge.log("PhoneAudioMonitor: Audio state changed -> \(isPlaying ? "PLAYING" : "STOPPED")")
+
+        DispatchQueue.main.async { [weak self] in
+            self?.listener?.onPhoneAudioStateChanged(isPlaying: isPlaying)
+        }
+    }
+
+    /// Clean up resources
+    func destroy() {
+        stopMonitoring()
+        PhoneAudioMonitor.instance = nil
+    }
+}

package/ios/Source/utils/TarBz2Extractor.swift

@@ -0,0 +1,206 @@
+import Compression
+import Foundation
+@_implementationOnly import libbz2
+import SWCompression
+
+@objc(TarBz2Extractor)
+public class TarBz2Extractor: NSObject {
+    private static let chunkSize = 1 << 16 // 64 KB
+
+    @objc
+    public static func extractTarBz2From(
+        _ sourcePath: String,
+        to destinationPath: String,
+        error errorPointer: NSErrorPointer
+    ) -> Bool {
+        Bridge.log("TarBz2Extractor: begin extraction")
+        do {
+            try performExtraction(from: sourcePath, to: destinationPath)
+            Bridge.log("TarBz2Extractor: extraction complete")
+            return true
+        } catch let extractionError as NSError {
+            Bridge.log("TarBz2Extractor: failed - \(extractionError.localizedDescription)")
+            errorPointer?.pointee = extractionError
+            return false
+        } catch {
+            let nsError = NSError(
+                domain: "TarBz2Extractor",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: error.localizedDescription]
+            )
+            Bridge.log("TarBz2Extractor: failed - \(error.localizedDescription)")
+            errorPointer?.pointee = nsError
+            return false
+        }
+    }
+
+    private static func performExtraction(from sourcePath: String, to destinationPath: String) throws {
+        let fileManager = FileManager.default
+        try fileManager.createDirectory(
+            atPath: destinationPath,
+            withIntermediateDirectories: true,
+            attributes: nil
+        )
+
+        let tempTarURL = try decompressBzipArchive(at: sourcePath)
+        defer { try? fileManager.removeItem(at: tempTarURL) }
+
+        try extractTarArchive(at: tempTarURL, to: destinationPath)
+        try flattenNestedDirectory(at: destinationPath)
+    }
+
+    private static func decompressBzipArchive(at sourcePath: String) throws -> URL {
+        let tempTarURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString)
+            .appendingPathExtension("tar")
+
+        guard let sourceFile = fopen(sourcePath, "rb") else {
+            throw makeError(code: 1001, message: "Unable to open source file at \(sourcePath)")
+        }
+        defer { fclose(sourceFile) }
+
+        guard let destinationFile = fopen(tempTarURL.path, "wb") else {
+            throw makeError(code: 1002, message: "Unable to create temporary tar file")
+        }
+        defer { fclose(destinationFile) }
+
+        var bzError: Int32 = BZ_OK
+        guard let bzFile = BZ2_bzReadOpen(&bzError, sourceFile, 0, 0, nil, 0), bzError == BZ_OK else {
+            throw makeError(code: 1003, message: "Unable to open bzip stream (code \(bzError))")
+        }
+
+        var buffer = [Int8](repeating: 0, count: chunkSize)
+        while true {
+            let bytesRead = BZ2_bzRead(&bzError, bzFile, &buffer, Int32(buffer.count))
+            if bzError == BZ_OK || bzError == BZ_STREAM_END {
+                if bytesRead > 0 {
+                    let written = buffer.withUnsafeBytes { rawBuffer -> Int in
+                        guard let baseAddress = rawBuffer.baseAddress else { return 0 }
+                        return fwrite(baseAddress, 1, Int(bytesRead), destinationFile)
+                    }
+                    guard written == Int(bytesRead) else {
+                        BZ2_bzReadClose(&bzError, bzFile)
+                        throw makeError(code: 1004, message: "Failed to write decompressed data")
+                    }
+                }
+                if bzError == BZ_STREAM_END {
+                    break
+                }
+            } else {
+                BZ2_bzReadClose(&bzError, bzFile)
+                throw makeError(code: 1005, message: "bzip2 read failed with code \(bzError)")
+            }
+        }
+
+        BZ2_bzReadClose(&bzError, bzFile)
+        guard bzError == BZ_OK else {
+            throw makeError(code: 1006, message: "bzip2 close failed with code \(bzError)")
+        }
+
+        return tempTarURL
+    }
+
+    private static func extractTarArchive(at tarURL: URL, to destinationPath: String) throws {
+        let destinationRoot = URL(fileURLWithPath: destinationPath, isDirectory: true)
+        let fileManager = FileManager.default
+
+        let handle = try FileHandle(forReadingFrom: tarURL)
+        defer { try? handle.close() }
+
+        var reader = TarReader(fileHandle: handle)
+
+        while let entry = try reader.read() {
+            let sanitizedName = sanitize(entryName: entry.info.name)
+            if sanitizedName.isEmpty {
+                continue
+            }
+
+            let entryURL = destinationRoot.appendingPathComponent(sanitizedName)
+            switch entry.info.type {
+            case .directory:
+                try fileManager.createDirectory(
+                    at: entryURL,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            case .regular:
+                guard let data = entry.data else { continue }
+                try fileManager.createDirectory(
+                    at: entryURL.deletingLastPathComponent(),
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+                let finalURL = remapModelFileIfNeeded(for: entryURL)
+                try data.write(to: finalURL, options: .atomic)
+            default:
+                continue
+            }
+        }
+    }
+
+    private static func flattenNestedDirectory(at destinationPath: String) throws {
+        let fileManager = FileManager.default
+        let destinationURL = URL(fileURLWithPath: destinationPath, isDirectory: true)
+        let nestedURL = destinationURL.appendingPathComponent(destinationURL.lastPathComponent)
+
+        guard fileManager.fileExists(atPath: nestedURL.path) else { return }
+
+        let nestedFiles = try fileManager.contentsOfDirectory(at: nestedURL, includingPropertiesForKeys: nil)
+        for file in nestedFiles {
+            let target = destinationURL.appendingPathComponent(file.lastPathComponent)
+            if fileManager.fileExists(atPath: target.path) {
+                try fileManager.removeItem(at: target)
+            }
+            try fileManager.moveItem(at: file, to: target)
+        }
+
+        try fileManager.removeItem(at: nestedURL)
+    }
+
+    private static func sanitize(entryName: String) -> String {
+        var name = entryName
+
+        if name.hasPrefix("./") {
+            name.removeFirst(2)
+        }
+        while name.hasPrefix("/") {
+            name.removeFirst()
+        }
+
+        guard !name.isEmpty else { return "" }
+
+        var components = name.split(separator: "/").map(String.init)
+        guard !components.isEmpty else { return "" }
+
+        if components.count > 1 {
+            components.removeFirst()
+            name = components.joined(separator: "/")
+        } else {
+            name = components[0]
+        }
+
+        return name
+    }
+
+    private static func remapModelFileIfNeeded(for url: URL) -> URL {
+        let parent = url.deletingLastPathComponent()
+        switch url.lastPathComponent {
+        case "encoder-epoch-99-avg-1.onnx":
+            return parent.appendingPathComponent("encoder.onnx")
+        case "decoder-epoch-99-avg-1.onnx":
+            return parent.appendingPathComponent("decoder.onnx")
+        case "joiner-epoch-99-avg-1.int8.onnx":
+            return parent.appendingPathComponent("joiner.onnx")
+        default:
+            return url
+        }
+    }
+
+    private static func makeError(code: Int, message: String) -> NSError {
+        return NSError(
+            domain: "TarBz2Extractor",
+            code: code,
+            userInfo: [NSLocalizedDescriptionKey: message]
+        )
+    }
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@mentra/bluetooth-sdk",
+  "version": "0.1.0",
+  "description": "SDK for communicating with smart glasses",
+  "main": "build/index.js",
+  "react-native": "src/index.ts",
+  "app.plugin": "app.plugin.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "android",
+    "!android/.gradle",
+    "!android/.gradle/**",
+    "!android/build",
+    "!android/build/**",
+    "!android/lc3Lib/.cxx",
+    "!android/lc3Lib/.cxx/**",
+    "!android/lc3Lib/build",
+    "!android/lc3Lib/build/**",
+    "app.plugin.js",
+    "build",
+    "expo-module.config.json",
+    "ios",
+    "!ios/build",
+    "!ios/build/**",
+    "!ios/Pods",
+    "!ios/Pods/**",
+    "plugin/build",
+    "README.md",
+    "src",
+    "!src/__tests__"
+  ],
+  "scripts": {
+    "build": "expo-module build",
+    "build:plugin": "expo-module build plugin",
+    "clean": "expo-module clean",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "lint": "expo-module lint",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "smart-glasses",
+    "bluetooth",
+    "ble",
+    "ar-glasses"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mentra-Community/MentraOS.git",
+    "directory": "mobile/modules/bluetooth-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/Mentra-Community/MentraOS/issues"
+  },
+  "author": "Mentra",
+  "license": "MIT",
+  "homepage": "https://github.com/Mentra-Community/MentraOS/tree/main/mobile/modules/bluetooth-sdk#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "expo-module-scripts": "^55.0.2"
+  },
+  "peerDependencies": {
+    "@expo/config-plugins": ">=8.0.0",
+    "@types/react": ">=18.0.0",
+    "expo": ">=49.0.0",
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,6 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+export interface BluetoothSdkPluginProps {
+    node?: boolean;
+}
+declare const withBluetoothSdk: ConfigPlugin<BluetoothSdkPluginProps>;
+export default withBluetoothSdk;

package/plugin/build/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const withAndroid_1 = require("./withAndroid");
+const withIos_1 = require("./withIos");
+const withBluetoothSdk = (config, props) => {
+    // Apply Android configurations
+    config = (0, withAndroid_1.withAndroidConfiguration)(config, props);
+    // Apply iOS configurations
+    config = (0, withIos_1.withIosConfiguration)(config, props);
+    return config;
+};
+exports.default = withBluetoothSdk;

package/plugin/build/withAndroid.d.ts

@@ -0,0 +1,4 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+export declare const withAndroidConfiguration: ConfigPlugin<{
+    node?: boolean;
+}>;

package/plugin/build/withAndroid.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAndroidConfiguration = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("expo/config-plugins");
+function getBluetoothSdkRoot() {
+    return path_1.default.dirname(require.resolve("../../package.json"));
+}
+function toGroovyString(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Modify settings.gradle to include lc3Lib module
+ */
+function withSettingsGradleModifications(config) {
+    return (0, config_plugins_1.withSettingsGradle)(config, (config) => {
+        let settingsGradle = config.modResults.contents;
+        // Add lc3Lib module if not present
+        if (!settingsGradle.includes("include ':lc3Lib'")) {
+            const bluetoothSdkRoot = getBluetoothSdkRoot();
+            settingsGradle += `
+  include ':lc3Lib'
+  project(':lc3Lib').projectDir = new File(${toGroovyString(bluetoothSdkRoot)}, 'android/lc3Lib')
+  `;
+        }
+        config.modResults.contents = settingsGradle;
+        return config;
+    });
+}
+/**
+ * Modify gradle.properties to add node path for native builds launched outside a shell.
+ */
+function withGradlePropertiesModifications(config) {
+    return (0, config_plugins_1.withGradleProperties)(config, (config) => {
+        let props = config.modResults;
+        // Get node path and add to org.gradle.jvmargs
+        try {
+            const nodeExecutable = (0, child_process_1.execSync)("which node", { encoding: "utf-8" }).trim();
+            // Get parent directory of bin (e.g., /path/to/node/bin/node -> /path/to/node)
+            const nodePath = path_1.default.dirname(nodeExecutable);
+            // Find existing org.gradle.jvmargs property
+            const jvmArgsIndex = props.findIndex((p) => p.type === "property" && p.key === "org.gradle.jvmargs");
+            if (jvmArgsIndex !== -1) {
+                // Append nodePath to existing jvmargs if not already present
+                const jvmArgsProp = props[jvmArgsIndex];
+                if (jvmArgsProp.type === "property" && "value" in jvmArgsProp) {
+                    const currentValue = jvmArgsProp.value;
+                    if (!currentValue.includes("-Dorg.gradle.project.nodePath=")) {
+                        jvmArgsProp.value = `${currentValue} -Dorg.gradle.project.nodePath=${nodePath}`;
+                    }
+                }
+            }
+            else {
+                // Create new jvmargs property with nodePath
+                props.push({
+                    type: "property",
+                    key: "org.gradle.jvmargs",
+                    value: `-Dorg.gradle.project.nodePath=${nodePath}`,
+                });
+            }
+        }
+        catch (error) {
+            console.warn("Failed to get node path:", error);
+        }
+        config.modResults = props;
+        return config;
+    });
+}
+const withAndroidConfiguration = (config, props) => {
+    config = withSettingsGradleModifications(config);
+    if (props?.node) {
+        config = withGradlePropertiesModifications(config);
+    }
+    return config;
+};
+exports.withAndroidConfiguration = withAndroidConfiguration;

package/plugin/build/withIos.d.ts

@@ -0,0 +1,4 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+export declare const withIosConfiguration: ConfigPlugin<{
+    node?: boolean;
+}>;

package/plugin/build/withIos.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withIosConfiguration = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("expo/config-plugins");
+const BLUETOOTH_SDK_EXPO_ADAPTER_ENV = "MENTRA_BLUETOOTH_SDK_INCLUDE_EXPO_ADAPTER";
+const BLUETOOTH_SDK_EXPO_ADAPTER_LINE = `ENV['${BLUETOOTH_SDK_EXPO_ADAPTER_ENV}'] ||= '1'`;
+const ensureBluetoothSdkExpoAdapterPodEnv = (podfile) => {
+    if (podfile.includes(BLUETOOTH_SDK_EXPO_ADAPTER_ENV)) {
+        return podfile;
+    }
+    const insertion = [
+        "  # Expo apps need the SDK's Expo module adapter so autolinking can register BluetoothSdk.",
+        `  ${BLUETOOTH_SDK_EXPO_ADAPTER_LINE}`,
+        "",
+    ].join("\n");
+    return podfile.replace(/(target\s+['"][^'"]+['"]\s+do\n)/, `$1${insertion}`);
+};
+const withXcodeEnvLocal = (config) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        "ios",
+        async (config) => {
+            try {
+                // Get node executable path
+                const nodeExecutable = (0, child_process_1.execSync)("which node", { encoding: "utf-8" }).trim();
+                // Path to .xcode.env.local
+                const iosPath = path_1.default.join(config.modRequest.platformProjectRoot);
+                const xcodeEnvLocalPath = path_1.default.join(iosPath, ".xcode.env.local");
+                // Content to write
+                const content = `export NODE_BINARY=${nodeExecutable}\n`;
+                // Write or append to .xcode.env.local
+                if (fs_1.default.existsSync(xcodeEnvLocalPath)) {
+                    const existingContent = fs_1.default.readFileSync(xcodeEnvLocalPath, "utf-8");
+                    if (!existingContent.includes("NODE_BINARY")) {
+                        fs_1.default.appendFileSync(xcodeEnvLocalPath, content);
+                    }
+                }
+                else {
+                    fs_1.default.writeFileSync(xcodeEnvLocalPath, content);
+                }
+            }
+            catch (error) {
+                console.warn("Failed to create .xcode.env.local:", error);
+            }
+            return config;
+        },
+    ]);
+};
+const withIosConfiguration = (config, props) => {
+    config = (0, config_plugins_1.withPodfile)(config, (config) => {
+        config.modResults.contents = ensureBluetoothSdkExpoAdapterPodEnv(config.modResults.contents);
+        return config;
+    });
+    if (props?.node) {
+        config = withXcodeEnvLocal(config);
+    }
+    return config;
+};
+exports.withIosConfiguration = withIosConfiguration;