@mentra/bluetooth-sdk 0.1.0

package/ios/Source/utils/AudioSessionMonitor.swift

@@ -0,0 +1,283 @@
+//
+//  AudioSessionMonitor.swift
+//  AOS
+//
+//  Monitors iOS AVAudioSession for Bluetooth audio device connections
+//  Used to detect when Mentra Live glasses are paired/connected for audio
+//
+
+import AVFoundation
+import Foundation
+import UIKit
+
+class AudioSessionMonitor {
+    /// Singleton instance
+    private static var instance: AudioSessionMonitor?
+
+    // Current monitoring state
+    static var isMonitoring = false
+    static var devicePattern: String?
+    static var callback: ((Bool, String?) -> Void)?
+
+    private init() {
+        Bridge.log("AudioMonitor: Initialized")
+    }
+
+    static func getInstance() -> AudioSessionMonitor {
+        if instance == nil {
+            instance = AudioSessionMonitor()
+        }
+        return instance!
+    }
+
+    /// Check if AVAudioSession is configured for Bluetooth
+    /// Returns true if session allows Bluetooth audio
+    /// NOTE: We don't configure the session - PhoneMic.swift handles that when recording
+    static func isAudioSessionConfigured() -> Bool {
+        let session = AVAudioSession.sharedInstance()
+
+        // Check if category supports Bluetooth
+        let category = session.category
+        let supportsBluetooth =
+            category == .playAndRecord || category == .record || category == .multiRoute
+
+        Bridge.log(
+            "AudioMonitor: Audio session category: \(category.rawValue), supports BT: \(supportsBluetooth)"
+        )
+        return supportsBluetooth
+    }
+
+    /// Check if a Bluetooth audio device matching the pattern is currently the active audio route
+    /// Returns true if device is actively routing audio
+    static func isAudioDeviceConnected(devicePattern: String) -> Bool {
+        let session = AVAudioSession.sharedInstance()
+        let outputs = session.currentRoute.outputs
+
+        Bridge.log("AudioMonitor: Checking active route, output count: \(outputs.count)")
+        for output in outputs {
+            Bridge.log("AudioMonitor:   - \(output.portName) (type: \(output.portType.rawValue))")
+            if output.portType == .bluetoothHFP || output.portType == .bluetoothA2DP {
+                if output.portName.localizedCaseInsensitiveContains(devicePattern) {
+                    Bridge.log("AudioMonitor: ✅ Found active audio device: \(output.portName)")
+                    return true
+                }
+            }
+        }
+
+        Bridge.log("AudioMonitor: No active audio device matching '\(devicePattern)'")
+        return false
+    }
+
+    static func isOtherAudioDeviceConnected(devicePattern: String) -> Bool {
+        let connected = isAudioDeviceConnected(devicePattern: devicePattern)
+        if connected {
+            return false
+        }
+
+        // do we have multiple devices connected?
+        let session = AVAudioSession.sharedInstance()
+        let outputs = session.currentRoute.outputs
+
+        Bridge.log("AudioMonitor: Checking active route, output count: \(outputs.count)")
+        if outputs.count > 1 {
+            return true
+        }
+
+        return false
+    }
+
+    /// Check if a Bluetooth device matching the pattern is paired (appears in availableInputs)
+    /// Returns true if device is found (paired), WITHOUT activating it
+    /// This avoids switching A2DP music playback to HFP microphone mode
+    static func isDevicePaired(devicePattern: String) -> Bool {
+        let session = AVAudioSession.sharedInstance()
+
+        // Check if already active (using A2DP for music or HFP for calls)
+        if isAudioDeviceConnected(devicePattern: devicePattern) {
+            Bridge.log("AudioMonitor: Device '\(devicePattern)' already active")
+            return true
+        }
+
+        // Try to find in availableInputs (includes paired devices)
+        guard let availableInputs = session.availableInputs else {
+            Bridge.log("AudioMonitor: ❌ availableInputs is nil")
+            return false
+        }
+
+        Bridge.log("AudioMonitor: availableInputs count: \(availableInputs.count)")
+        for input in availableInputs {
+            Bridge.log("AudioMonitor:   - \(input.portName) (type: \(input.portType.rawValue))")
+        }
+
+        let bluetoothInput = availableInputs.first { input in
+            input.portType == .bluetoothHFP
+                && input.portName.localizedCaseInsensitiveContains(devicePattern)
+        }
+
+        if let btInput = bluetoothInput {
+            Bridge.log(
+                "AudioMonitor: ✅ Found paired device '\(btInput.portName)' (not activating to preserve A2DP)"
+            )
+            return true
+        } else {
+            Bridge.log(
+                "AudioMonitor: ❌ Bluetooth HFP device '\(devicePattern)' not found in availableInputs"
+            )
+            return false
+        }
+    }
+
+    /// Start monitoring for audio route changes
+    /// Callback will be called when device matching pattern connects/disconnects
+    static func startMonitoring(devicePattern: String, callback: @escaping (Bool, String?) -> Void) {
+        guard !isMonitoring else {
+            Bridge.log("AudioMonitor: Already monitoring")
+            return
+        }
+
+        self.devicePattern = devicePattern
+        self.callback = callback
+
+        // Register for route change notifications
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleRouteChange),
+            name: AVAudioSession.routeChangeNotification,
+            object: nil
+        )
+
+        // Register for app foreground notifications
+        // This handles the case where user pairs in Settings and returns to app
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppBecameActive),
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+
+        isMonitoring = true
+        Bridge.log("AudioMonitor: Started monitoring for '\(devicePattern)'")
+    }
+
+    /// Stop monitoring for audio route changes
+    static func stopMonitoring() {
+        guard isMonitoring else {
+            Bridge.log("AudioMonitor: Not currently monitoring")
+            return
+        }
+
+        NotificationCenter.default.removeObserver(
+            self,
+            name: AVAudioSession.routeChangeNotification,
+            object: nil
+        )
+
+        NotificationCenter.default.removeObserver(
+            self,
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+
+        AudioSessionMonitor.isMonitoring = false
+        AudioSessionMonitor.devicePattern = nil
+        AudioSessionMonitor.callback = nil
+
+        Bridge.log("AudioMonitor: Stopped monitoring")
+    }
+
+    @objc private func handleRouteChange(notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let reasonValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
+              let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue),
+              let pattern = AudioSessionMonitor.devicePattern
+        else {
+            return
+        }
+
+        Bridge.log("AudioMonitor: Route change detected: \(reason.rawValue)")
+
+        switch reason {
+        case .newDeviceAvailable:
+            // When a new device becomes available, try to set it as preferred
+            // This handles the case where user pairs in Settings and returns to app
+            Bridge.log("AudioMonitor: New device available, attempting to activate '\(pattern)'")
+
+            // Add small delay to let iOS populate availableInputs
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+                if AudioSessionMonitor.isDevicePaired(devicePattern: pattern) {
+                    let session = AVAudioSession.sharedInstance()
+                    let deviceName = session.availableInputs?.first(where: {
+                        $0.portName.localizedCaseInsensitiveContains(pattern)
+                    })?.portName
+                    Bridge.log(
+                        "AudioMonitor: ✅ Successfully detected newly paired device '\(pattern)'"
+                    )
+                    AudioSessionMonitor.callback?(true, deviceName)
+                } else {
+                    Bridge.log("AudioMonitor: New device available but not matching '\(pattern)'")
+                }
+            }
+
+        case .oldDeviceUnavailable:
+            // Check if our device disconnected
+            if !AudioSessionMonitor.isAudioDeviceConnected(devicePattern: pattern) {
+                Bridge.log("AudioMonitor: Device '\(pattern)' disconnected")
+                AudioSessionMonitor.callback?(false, nil)
+            }
+
+        default:
+            break
+        }
+    }
+
+    @objc private static func handleAppBecameActive() {
+        guard let pattern = AudioSessionMonitor.devicePattern else { return }
+
+        Bridge.log("AudioMonitor: App became active, checking for paired device '\(pattern)'")
+
+        // Don't reconfigure session - it's already configured from when monitoring started
+        // Just wait a bit for iOS to update availableInputs after returning from background
+        // iOS needs time to populate availableInputs after app foreground
+        // Use retry with progressive delays: 100ms, 400ms, 500ms = 1s total
+        AudioSessionMonitor.attemptActivateDevice(pattern: pattern, attempt: 0, maxAttempts: 3)
+    }
+
+    /// Try to detect if the audio device is paired with retry logic
+    /// Delays: [100ms, 400ms, 500ms] = 1 second total
+    static func attemptActivateDevice(pattern: String, attempt: Int, maxAttempts: Int) {
+        // Progressive delays in seconds (total: 1 second)
+        let delays: [TimeInterval] = [0.1, 0.4, 0.5]
+
+        if attempt >= maxAttempts {
+            Bridge.log(
+                "AudioMonitor: ❌ Failed to find paired device '\(pattern)' after \(maxAttempts) attempts"
+            )
+            return
+        }
+
+        let delay = attempt < delays.count ? delays[attempt] : 0.5
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
+            Bridge.log(
+                "AudioMonitor: Attempt \(attempt + 1)/\(maxAttempts) to detect '\(pattern)'..."
+            )
+
+            if AudioSessionMonitor.isDevicePaired(devicePattern: pattern) {
+                let session = AVAudioSession.sharedInstance()
+                // Try to get device name from availableInputs
+                let deviceName = session.availableInputs?.first(where: {
+                    $0.portName.localizedCaseInsensitiveContains(pattern)
+                })?.portName
+                Bridge.log("AudioMonitor: ✅ Found paired device on attempt \(attempt + 1)")
+                AudioSessionMonitor.callback?(true, deviceName)
+            } else {
+                Bridge.log(
+                    "AudioMonitor: Attempt \(attempt + 1) failed, retrying in \(delays[min(attempt + 1, delays.count - 1)])s..."
+                )
+                AudioSessionMonitor.attemptActivateDevice(
+                    pattern: pattern, attempt: attempt + 1, maxAttempts: maxAttempts
+                )
+            }
+        }
+    }
+}

package/ios/Source/utils/Constants.swift

@@ -0,0 +1,74 @@
+struct DeviceTypes {
+    static let SIMULATED = "Simulated Glasses"
+    static let G1 = "Even Realities G1"
+    static let G2 = "Even Realities G2"
+    static let LIVE = "Mentra Live"
+    static let MACH1 = "Mentra Mach1"
+    static let Z100 = "Vuzix Z100"
+    static let NEX = "Mentra Display"
+    static let FRAME = "Brilliant Frame"
+
+    static let ALL = [
+        SIMULATED,
+        G1,
+        G2,
+        MACH1,
+        LIVE,
+        Z100,
+        NEX,
+        FRAME,
+    ]
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+struct ControllerTypes {
+    static let R1 = "Even Realities R1"
+
+    static let ALL = [
+        R1,
+    ]
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+struct ConnTypes {
+    static let CONNECTING = "CONNECTING"
+    static let CONNECTED = "CONNECTED"
+    static let DISCONNECTED = "DISCONNECTED"
+    static let SCANNING = "SCANNING"
+    static let BONDING = "BONDING"
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+struct MicTypes {
+    static let PHONE_INTERNAL = "phone"
+    static let GLASSES_CUSTOM = "glasses"
+    static let BT_CLASSIC = "btclassic"
+    static let BT = "bt"
+
+    static let ALL = [
+        PHONE_INTERNAL,
+        GLASSES_CUSTOM,
+        BT_CLASSIC,
+        BT,
+    ]
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+enum MicMap {
+    static var map: [String: [String]] = [
+        "auto": [
+            MicTypes.GLASSES_CUSTOM, MicTypes.PHONE_INTERNAL, MicTypes.BT, MicTypes.BT_CLASSIC,
+        ],
+        "glasses": [MicTypes.GLASSES_CUSTOM],
+        "phone": [MicTypes.PHONE_INTERNAL, MicTypes.GLASSES_CUSTOM],
+        "bluetooth": [MicTypes.BT, MicTypes.PHONE_INTERNAL, MicTypes.GLASSES_CUSTOM],
+    ]
+}

package/ios/Source/utils/Enums.swift

@@ -0,0 +1,95 @@
+//
+//  Enums.swift
+//  MentraOS_Manager
+//
+//  Created by Matthew Fosse on 3/3/25.
+//
+
+import Foundation
+
+enum CommandResponse: UInt8 {
+    case ACK = 0xC9
+    case CONTINUE = 0xCB
+}
+
+enum Commands: UInt8 {
+    case BLE_EXIT_ALL_FUNCTIONS = 0x18
+    case BLE_REQ_INIT = 0x4D
+    case BLE_REQ_BATTERY = 0x2C
+    case BLE_REQ_HEARTBEAT = 0x25
+    case BLE_REQ_EVENAI = 0x4E
+    case BLE_REQ_TRANSFER_MIC_DATA = 0xF1
+    case BLE_REQ_DEVICE_ORDER = 0xF5
+    case BLE_REQ_MIC_ON = 0x0E
+    case QUICK_NOTE_ADD = 0x1E
+    case CRC_CHECK = 0x16
+    case BMP_END = 0x20
+    case BRIGHTNESS = 0x01
+    case WHITELIST = 0x04
+    case SILENT_MODE = 0x03
+    case DASHBOARD_LAYOUT_COMMAND = 0x26
+    case DASHBOARD_SHOW = 0x06
+    case HEAD_UP_ANGLE = 0x0B
+    case UNK_2 = 0x39
+    case UNK_1 = 0x50
+}
+
+enum DeviceOrders: UInt8 {
+    case DISPLAY_READY = 0x00
+    case TRIGGER_CHANGE_PAGE = 0x01
+    case TRIGGER_FOR_AI = 0x17
+    case TRIGGER_FOR_STOP_RECORDING = 0x18
+    case G1_IS_READY = 0x09
+    case HEAD_UP = 0x1E
+    case HEAD_DOWN = 0x1F
+    case SILENCED = 0x04
+    case ACTIVATED = 0x05
+    case HEAD_UP2 = 0x02
+    case HEAD_DOWN2 = 0x03
+    case CASE_REMOVED = 0x07
+    case CASE_REMOVED2 = 0x06
+    case CASE_OPEN = 0x08
+    case CASE_CLOSED = 0x0B
+    case CASE_CHARGING_STATUS = 0x0E
+    case CASE_CHARGE_INFO = 0x0F
+    case DOUBLE_TAP = 0x20
+}
+
+enum DisplayStatus: UInt8 {
+    case NORMAL_TEXT = 0x30
+    case FINAL_TEXT = 0x40
+    case MANUAL_PAGE = 0x50
+    case ERROR_TEXT = 0x60
+    case SIMPLE_TEXT = 0x70
+}
+
+public enum DashboardHeight: UInt8 {
+    case position0 = 0x00 // Bottom
+    case position1 = 0x01
+    case position2 = 0x02
+    case position3 = 0x03
+    case position4 = 0x04
+    case position5 = 0x05
+    case position6 = 0x06
+    case position7 = 0x07
+    case position8 = 0x08 // Top
+}
+
+public enum DashboardDepth: UInt8 {
+    case position0 = 0x00 // Bottom
+    case position1 = 0x01
+    case position2 = 0x02
+    case position3 = 0x03
+    case position4 = 0x04
+    case position5 = 0x05
+    case position6 = 0x06
+    case position7 = 0x07
+    case position8 = 0x08
+    case position9 = 0x09
+}
+
+public enum DashboardMode: UInt8 {
+    case full = 0x00
+    case dual = 0x01
+    case minimal = 0x02
+}