@siteed/expo-audio-studio 2.18.6 → 3.0.0

package/ios/AudioDeviceManager.swift

@@ -1,670 +0,0 @@
-//
-//  AudioDeviceManager.swift
-//  Pods
-//
-//  Created by Arthur on 4/29/25.
-//
-
-import Foundation
-import AVFoundation
-import ExpoModulesCore
-
-// MARK: - Delegate Protocol
-protocol AudioDeviceManagerDelegate: AnyObject {
-    func audioDeviceManager(_ manager: AudioDeviceManager, didDetectDisconnectionOfDevice deviceId: String)
-    // Future delegate methods can be added here
-}
-
-/// Manages audio device detection, selection and capabilities
-class AudioDeviceManager {
-    // MARK: - Properties
-    weak var delegate: AudioDeviceManagerDelegate? // Add delegate property
-
-    // MARK: - Device Type Constants
-    
-    // Constants for device types - standardized across platforms
-    private let deviceTypeBuiltinMic = "builtin_mic"
-    private let deviceTypeBluetooth = "bluetooth"
-    private let deviceTypeUSB = "usb"
-    private let deviceTypeWiredHeadset = "wired_headset"
-    private let deviceTypeWiredHeadphones = "wired_headphones"
-    private let deviceTypeSpeaker = "speaker"
-    private let deviceTypeUnknown = "unknown"
-    
-    // Flag to prevent infinite loops
-    private static var isAudioSessionPrepared = false
-    private static var lastPreparationTime: TimeInterval = 0
-
-    // Observer handle
-    private var routeChangeObserver: Any?
-
-    // MARK: - Initialization and Deinitialization
-    init() {
-        // Start monitoring route changes on initialization
-        startMonitoringDeviceChanges()
-    }
-
-    deinit {
-        // Stop monitoring when the instance is deallocated
-        stopMonitoringDeviceChanges()
-    }
-
-    // MARK: - Public Methods
-    
-    /// Maps AVAudioSession port types to standardized device types
-    func mapDeviceType(_ portType: AVAudioSession.Port) -> String {
-        Logger.debug("AudioDeviceManager", "Mapping device type for port: \(portType.rawValue)")
-        switch portType {
-        case .builtInMic:
-            return deviceTypeBuiltinMic
-        case .bluetoothHFP, .bluetoothA2DP, .bluetoothLE:
-            return deviceTypeBluetooth
-        case .headphones:
-            return deviceTypeWiredHeadphones
-        case .headsetMic:
-            return deviceTypeWiredHeadset
-        case .usbAudio:
-            return deviceTypeUSB
-        case .builtInSpeaker:
-            return deviceTypeSpeaker
-        default:
-            return deviceTypeUnknown
-        }
-    }
-    
-    /// Prepares the audio session to detect all available devices, including Bluetooth
-    private func prepareAudioSession(force: Bool = false) -> Bool {
-        // Skip preparation if already prepared and not forcing
-        let now = Date().timeIntervalSince1970
-        let timeSinceLastPreparation = now - AudioDeviceManager.lastPreparationTime
-        
-        if AudioDeviceManager.isAudioSessionPrepared && !force && timeSinceLastPreparation < 5.0 {
-            Logger.debug("AudioDeviceManager", "Audio session already prepared, skipping")
-            return true
-        }
-        
-        Logger.debug("AudioDeviceManager", "Preparing audio session for device detection")
-        do {
-            let session = AVAudioSession.sharedInstance()
-            
-            // Preserve existing session configuration if already set up for recording
-            if session.category == .playAndRecord {
-                Logger.debug("AudioDeviceManager", "Session already .playAndRecord, preserving categoryOptions")
-                try session.setActive(true, options: .notifyOthersOnDeactivation)
-            } else {
-                // Configure with options needed for Bluetooth detection
-                try session.setCategory(.playAndRecord, mode: .default, options: [.allowBluetooth, .allowBluetoothA2DP, .mixWithOthers])
-                try session.setActive(true, options: .notifyOthersOnDeactivation)
-            }
-            
-            // Give the system a moment to detect Bluetooth devices if needed
-            // Minimal delay that still allows devices to be detected
-            Thread.sleep(forTimeInterval: 0.1)
-            
-            // Mark as prepared
-            AudioDeviceManager.isAudioSessionPrepared = true
-            AudioDeviceManager.lastPreparationTime = now
-            
-            Logger.debug("AudioDeviceManager", "Audio session prepared for device detection")
-            return true
-        } catch {
-            Logger.debug("AudioDeviceManager", "Failed to prepare audio session: \(error.localizedDescription)")
-            return false
-        }
-    }
-    
-    /// Force a refresh of the audio session preparation
-    public func forceRefreshAudioSession() -> Bool {
-        // Only allow force refresh once every second to prevent excessive refreshes
-        let now = Date().timeIntervalSince1970
-        let timeSinceLastPreparation = now - AudioDeviceManager.lastPreparationTime
-        
-        if timeSinceLastPreparation < 1.0 {
-            Logger.debug("AudioDeviceManager", "Skipping force refresh - too soon since last preparation (\(timeSinceLastPreparation) seconds)")
-            return false
-        }
-        
-        return prepareAudioSession(force: true)
-    }
-    
-    /// Gets capabilities for an audio input device
-    func getDeviceCapabilities(_ port: AVAudioSessionPortDescription) -> [String: Any] {
-        Logger.debug("AudioDeviceManager", "Getting capabilities for device: \(port.portName) (ID: \(port.uid))")
-        let session = AVAudioSession.sharedInstance()
-        
-        // Test standard sample rates for support
-        let sampleRates = [8000, 16000, 22050, 44100, 48000, 96000].filter { rate in
-            let format = AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: Double(rate), channels: 1, interleaved: false)
-            return session.isInputAvailable && format != nil
-        }
-        
-        return [
-            "sampleRates": sampleRates,
-            "channelCounts": [1, 2], // Most iOS devices support mono and stereo
-            "bitDepths": [16, 24],   // Common bit depths on iOS
-            "hasEchoCancellation": true, // iOS doesn't expose this per-device, set to true as it's generally available
-            "hasNoiseSuppression": true, // iOS doesn't expose this per-device, set to true as it's generally available
-            "hasAutomaticGainControl": true // iOS doesn't expose this per-device, set to true as it's generally available
-        ]
-    }
-    
-    /// Gets a list of available audio input devices
-    func getAvailableInputDevices(promise: Promise) {
-        Logger.debug("AudioDeviceManager", "Getting available input devices")
-        
-        // Prepare audio session if needed
-        let prepared = prepareAudioSession()
-        if !prepared {
-            Logger.debug("AudioDeviceManager", "Warning: Audio session preparation failed, device list may be incomplete")
-        }
-        
-        do {
-            let session = AVAudioSession.sharedInstance()
-            
-            // We should have already activated the session in prepareAudioSession
-            // But ensure it's active just in case
-            try session.setActive(true)
-            
-            let currentPreferredInput = session.preferredInput
-            
-            var devices = [[String: Any]]()
-            
-            // First add current route devices as they're definitely available
-            for input in session.currentRoute.inputs {
-                let deviceType = mapDeviceType(input.portType)
-                let isDefault = currentPreferredInput == nil ?
-                    (input.portType == .builtInMic) : // Default is usually built-in mic
-                    (input.uid == currentPreferredInput?.uid)
-                
-                let deviceId = normalizeBluetoothDeviceId(input.uid)
-                
-                Logger.debug("AudioDeviceManager", "Current route device: \(input.portName) (type: \(deviceType), ID: \(deviceId))")
-                
-                devices.append([
-                    "id": deviceId,
-                    "name": input.portName,
-                    "type": deviceType,
-                    "isDefault": isDefault,
-                    "capabilities": getDeviceCapabilities(input),
-                    "isAvailable": true,
-                    "source": "currentRoute"
-                ])
-            }
-            
-            // Then add from availableInputs
-            if let availableInputs = session.availableInputs {
-                for port in availableInputs {
-                    let deviceType = mapDeviceType(port.portType)
-                    let isDefault = currentPreferredInput == nil ?
-                        (port.portType == .builtInMic) : // Default is usually built-in mic
-                        (port.uid == currentPreferredInput?.uid)
-                    
-                    let deviceId = normalizeBluetoothDeviceId(port.uid)
-                    
-                    // Skip if already in our list
-                    if !devices.contains(where: { ($0["id"] as? String) == deviceId }) {
-                        Logger.debug("AudioDeviceManager", "Available input: \(port.portName) (type: \(deviceType), ID: \(deviceId))")
-                        
-                        devices.append([
-                            "id": deviceId,
-                            "name": port.portName,
-                            "type": deviceType,
-                            "isDefault": isDefault,
-                            "capabilities": getDeviceCapabilities(port),
-                            "isAvailable": true,
-                            "source": "availableInputs"
-                        ])
-                    }
-                }
-            }
-            
-            Logger.debug("AudioDeviceManager", "Found \(devices.count) available input devices")
-            promise.resolve(devices)
-        } catch {
-            Logger.debug("AudioDeviceManager", "Error getting available input devices: \(error.localizedDescription)")
-            promise.reject("DEVICE_DETECTION_ERROR", "Failed to get available audio devices: \(error.localizedDescription)")
-        }
-    }
-    
-    /// Gets the currently selected audio input device
-    func getCurrentInputDevice(promise: Promise) {
-        Logger.debug("AudioDeviceManager", "Getting current input device")
-        
-        // Prepare audio session if needed
-        let prepared = prepareAudioSession()
-        if !prepared {
-            Logger.debug("AudioDeviceManager", "Warning: Audio session preparation failed, current device may not be correctly detected")
-        }
-        
-        do {
-            let session = AVAudioSession.sharedInstance()
-            
-            // We should have already activated the session in prepareAudioSession
-            // But ensure it's active just in case
-            try session.setActive(true)
-            
-            // Check current route first
-            if let currentPort = session.currentRoute.inputs.first {
-                let deviceType = mapDeviceType(currentPort.portType)
-                let isDefault = session.preferredInput == nil || session.preferredInput?.portType == currentPort.portType
-                let deviceId = normalizeBluetoothDeviceId(currentPort.uid)
-                
-                Logger.debug("AudioDeviceManager", "Current input device: \(currentPort.portName) (ID: \(deviceId), type: \(deviceType))")
-                
-                let device: [String: Any] = [
-                    "id": deviceId,
-                    "name": currentPort.portName,
-                    "type": deviceType,
-                    "isDefault": isDefault,
-                    "capabilities": getDeviceCapabilities(currentPort),
-                    "isAvailable": true,
-                    "source": "currentRoute"
-                ]
-                
-                promise.resolve(device)
-                return
-            }
-            
-            // Fallback to preferred input
-            if let preferredInput = session.preferredInput {
-                let deviceType = mapDeviceType(preferredInput.portType)
-                let deviceId = normalizeBluetoothDeviceId(preferredInput.uid)
-                
-                Logger.debug("AudioDeviceManager", "Current input from preferred: \(preferredInput.portName) (ID: \(deviceId), type: \(deviceType))")
-                
-                let device: [String: Any] = [
-                    "id": deviceId,
-                    "name": preferredInput.portName,
-                    "type": deviceType,
-                    "isDefault": true,
-                    "capabilities": getDeviceCapabilities(preferredInput),
-                    "isAvailable": true,
-                    "source": "preferredInput"
-                ]
-                
-                promise.resolve(device)
-                return
-            }
-            
-            // No input device is currently selected
-            Logger.debug("AudioDeviceManager", "No current input device found")
-            promise.resolve(nil)
-        } catch {
-            Logger.debug("AudioDeviceManager", "Error getting current input device: \(error.localizedDescription)")
-            promise.reject("DEVICE_DETECTION_ERROR", "Failed to get current audio device: \(error.localizedDescription)")
-        }
-    }
-    
-    /// Gets the default audio input device (usually built-in mic)
-    /// This is an async version useful for fallback logic.
-    func getDefaultInputDevice() async -> AudioDevice? {
-        Logger.debug("AudioDeviceManager", "Getting default input device")
-
-        let prepared = prepareAudioSession()
-        if !prepared {
-            Logger.debug("AudioDeviceManager", "Warning: Audio session preparation failed, default device detection may be inaccurate")
-        }
-
-        let session = AVAudioSession.sharedInstance()
-        do {
-            try session.setActive(true) // Ensure session is active
-
-            // Find the built-in microphone port, which is typically the default fallback
-            if let defaultPort = session.availableInputs?.first(where: { $0.portType == .builtInMic }) {
-                let deviceType = mapDeviceType(defaultPort.portType)
-                let deviceId = normalizeBluetoothDeviceId(defaultPort.uid)
-                let capabilities = getDeviceCapabilities(defaultPort)
-
-                 Logger.debug("AudioDeviceManager", "Found default device: \(defaultPort.portName) (ID: \(deviceId), Type: \(deviceType))")
-
-                // Convert capabilities dictionary to Capabilities struct/object if needed
-                 let audioCapabilities = AudioDeviceCapabilities(
-                     sampleRates: capabilities["sampleRates"] as? [Int] ?? [],
-                     channelCounts: capabilities["channelCounts"] as? [Int] ?? [],
-                     bitDepths: capabilities["bitDepths"] as? [Int] ?? []
-                     // Add boolean flags if available in your dictionary
-                 )
-
-                 return AudioDevice(
-                     id: deviceId,
-                     name: defaultPort.portName,
-                     type: deviceType,
-                     isDefault: true, // Assume it's the default we're looking for
-                     capabilities: audioCapabilities,
-                     isAvailable: true // It's available if found here
-                 )
-            } else {
-                Logger.debug("AudioDeviceManager", "Could not find built-in mic as default device.")
-                return nil
-            }
-        } catch {
-            Logger.debug("AudioDeviceManager", "Error getting default input device: \(error)")
-            return nil
-        }
-    }
-    
-    /// Selects a specific audio input device for recording
-    func selectInputDevice(_ deviceId: String, promise: Promise) {
-        Logger.debug("AudioDeviceManager", "Attempting to select input device with ID: \(deviceId)")
-        
-        // Prepare audio session - use force: true for device selection to ensure we get the latest devices
-        let prepared = prepareAudioSession(force: true)
-        if !prepared {
-            Logger.debug("AudioDeviceManager", "Warning: Audio session preparation failed, device selection may not work correctly")
-        }
-        
-        do {
-            let session = AVAudioSession.sharedInstance()
-            
-            // Ensure the session is active
-            try session.setActive(true)
-            
-            // For Bluetooth devices, normalize and match by prefix
-            let normalizedRequestedId = normalizeBluetoothDeviceId(deviceId)
-            let isBluetoothDevice = deviceId.contains(":")
-            
-            Logger.debug("AudioDeviceManager", "Selecting \(isBluetoothDevice ? "Bluetooth" : "non-Bluetooth") device with normalized ID: \(normalizedRequestedId)")
-            
-            // Find the device with the specified ID
-            let selectedPort: AVAudioSessionPortDescription?
-            
-            if isBluetoothDevice {
-                // For Bluetooth devices, match by normalized ID
-                selectedPort = session.availableInputs?.first { port in
-                    let portNormalizedId = normalizeBluetoothDeviceId(port.uid)
-                    let matches = portNormalizedId == normalizedRequestedId
-                    Logger.debug("AudioDeviceManager", "Checking device \(port.portName) (ID: \(port.uid), Normalized: \(portNormalizedId)) - Matches: \(matches)")
-                    return matches
-                }
-            } else {
-                // For non-Bluetooth devices, direct match
-                selectedPort = session.availableInputs?.first { port in
-                    let matches = port.uid == deviceId
-                    Logger.debug("AudioDeviceManager", "Checking device \(port.portName) (ID: \(port.uid)) - Matches: \(matches)")
-                    return matches
-                }
-            }
-            
-            guard let selectedPort = selectedPort else {
-                Logger.debug("AudioDeviceManager", "Device not found with ID \(deviceId)")
-                
-                // Log all available devices to help debugging
-                if let availableInputs = session.availableInputs {
-                    Logger.debug("AudioDeviceManager", "Available devices:")
-                    for (index, device) in availableInputs.enumerated() {
-                        Logger.debug("AudioDeviceManager", "\(index+1). \(device.portName) (ID: \(device.uid), Normalized: \(normalizeBluetoothDeviceId(device.uid)))")
-                    }
-                } else {
-                    Logger.debug("AudioDeviceManager", "No available devices found")
-                }
-                
-                promise.reject("DEVICE_NOT_FOUND", "The selected audio device is not available")
-                return
-            }
-            
-            // Set the preferred input device
-            Logger.debug("AudioDeviceManager", "Setting preferred input to: \(selectedPort.portName) (ID: \(selectedPort.uid))")
-            try session.setPreferredInput(selectedPort)
-            
-            // Verify selection
-            if let currentInput = session.currentRoute.inputs.first {
-                let succeeded = (currentInput.uid == selectedPort.uid || 
-                                normalizeBluetoothDeviceId(currentInput.uid) == normalizeBluetoothDeviceId(selectedPort.uid))
-                Logger.debug("AudioDeviceManager", "Device selection \(succeeded ? "succeeded" : "failed") - Current device: \(currentInput.portName) (ID: \(currentInput.uid))")
-            }
-            
-            Logger.debug("AudioDeviceManager", "Device selected successfully")
-            promise.resolve(true)
-        } catch {
-            Logger.debug("AudioDeviceManager", "Failed to select device: \(error.localizedDescription)")
-            promise.reject("DEVICE_SELECTION_FAILED", "Failed to select audio device: \(error.localizedDescription)")
-        }
-    }
-    
-    /// Selects a specific audio input device asynchronously (useful for internal calls)
-    func selectDevice(_ deviceId: String) async -> Bool {
-        Logger.debug("AudioDeviceManager", "Attempting to select input device with ID: \(deviceId) (async)")
-
-        let prepared = prepareAudioSession(force: true)
-        if !prepared {
-            Logger.debug("AudioDeviceManager", "Warning: Audio session preparation failed, device selection may not work correctly")
-            return false
-        }
-
-        do {
-            let session = AVAudioSession.sharedInstance()
-            try session.setActive(true)
-
-            let normalizedRequestedId = normalizeBluetoothDeviceId(deviceId)
-            let isBluetoothDevice = deviceId.contains(":")
-
-            Logger.debug("AudioDeviceManager", "Selecting \(isBluetoothDevice ? "Bluetooth" : "non-Bluetooth") device with normalized ID: \(normalizedRequestedId)")
-
-            let selectedPort: AVAudioSessionPortDescription?
-            if isBluetoothDevice {
-                selectedPort = session.availableInputs?.first { port in
-                    normalizeBluetoothDeviceId(port.uid) == normalizedRequestedId
-                }
-            } else {
-                selectedPort = session.availableInputs?.first { $0.uid == deviceId }
-            }
-
-            guard let portToSet = selectedPort else {
-                Logger.debug("AudioDeviceManager", "Device not found with ID \(deviceId) for async selection")
-                return false
-            }
-
-            Logger.debug("AudioDeviceManager", "Setting preferred input to: \(portToSet.portName) (ID: \(portToSet.uid)) (async)")
-            try session.setPreferredInput(portToSet)
-             // Add a small delay hoping the system applies the change before potential next operations
-            try await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
-
-            // Optional: Verify selection succeeded (might be less reliable immediately after setting)
-            if let currentInput = session.currentRoute.inputs.first {
-                 let succeeded = (currentInput.uid == portToSet.uid || normalizeBluetoothDeviceId(currentInput.uid) == normalizedRequestedId)
-                 Logger.debug("AudioDeviceManager", "Async selection verification: \(succeeded ? "succeeded" : "failed")")
-                 return succeeded
-             } else {
-                 // If no current input after setting, assume failure
-                 return false
-             }
-
-        } catch {
-            Logger.debug("AudioDeviceManager", "Failed to select device asynchronously: \(error.localizedDescription)")
-            return false
-        }
-    }
-    
-    /// Determines if a device is still available
-    func isDeviceAvailable(_ deviceId: String) -> Bool {
-        Logger.debug("AudioDeviceManager", "Checking availability for device ID: \(deviceId)")
-        
-        // Prepare audio session if needed
-        let prepared = prepareAudioSession()
-        if !prepared {
-            Logger.debug("AudioDeviceManager", "Warning: Audio session preparation failed, device availability check may not be accurate")
-        }
-        
-        let session = AVAudioSession.sharedInstance()
-        
-        // Handle Bluetooth devices with multiple profiles (SCO, A2DP, etc.)
-        let isBluetoothDevice = deviceId.contains(":")  // Most Bluetooth devices have MAC addresses with colons
-        
-        if isBluetoothDevice {
-            // For Bluetooth devices, check if any device with the same MAC address prefix is available
-            let baseDeviceId = deviceId.split(separator: "-").first ?? Substring(deviceId)
-            
-            // Log all available inputs for debugging
-            Logger.debug("AudioDeviceManager", "Available devices to check against:")
-            if let availableInputs = session.availableInputs {
-                for (index, device) in availableInputs.enumerated() {
-                    let normalizedId = normalizeBluetoothDeviceId(device.uid)
-                    let matches = device.uid.starts(with: String(baseDeviceId))
-                    Logger.debug("AudioDeviceManager", "\(index+1). \(device.portName) (ID: \(device.uid), Normalized: \(normalizedId)) - Matches: \(matches)")
-                }
-            } else {
-                Logger.debug("AudioDeviceManager", "No available devices found")
-            }
-            
-            // Also check current route
-            for (index, input) in session.currentRoute.inputs.enumerated() {
-                let normalizedId = normalizeBluetoothDeviceId(input.uid)
-                let matches = input.uid.starts(with: String(baseDeviceId))
-                Logger.debug("AudioDeviceManager", "Current route input \(index+1): \(input.portName) (ID: \(input.uid), Normalized: \(normalizedId)) - Matches: \(matches)")
-            }
-            
-            let result = session.availableInputs?.contains { $0.uid.starts(with: String(baseDeviceId)) } ?? false
-            Logger.debug("AudioDeviceManager", "Bluetooth device \(deviceId) with base ID \(baseDeviceId) available: \(result)")
-            return result
-        } else {
-            // Standard device ID check for non-Bluetooth devices
-            return session.availableInputs?.contains { $0.uid == deviceId } ?? false
-        }
-    }
-    
-    /// Resets the selected device to system default (usually built-in mic)
-    /// - Parameter completion: Callback with success (Bool) and optional error
-    func resetToDefaultDevice(completion: @escaping (Bool, Error?) -> Void) {
-        Logger.debug("AudioDeviceManager", "Attempting to reset to default input device")
-        
-        // Prepare audio session if needed
-        let prepared = prepareAudioSession()
-        if !prepared {
-            Logger.debug("AudioDeviceManager", "Warning: Audio session preparation failed, device reset may not work correctly")
-        }
-        
-        do {
-            let session = AVAudioSession.sharedInstance()
-            
-            // Log current device before reset
-            if let currentDevice = session.currentRoute.inputs.first {
-                Logger.debug("AudioDeviceManager", "Current device before reset: \(currentDevice.portName) (ID: \(currentDevice.uid))")
-            } else {
-                Logger.debug("AudioDeviceManager", "No current device before reset")
-            }
-            
-            // Setting preferred input to nil lets the system choose the default
-            try session.setPreferredInput(nil)
-            
-            // Log the device after reset
-            if let newDevice = session.currentRoute.inputs.first {
-                Logger.debug("AudioDeviceManager", "Reset to default device: \(newDevice.portName) (ID: \(newDevice.uid))")
-                
-                // Check if it's actually the built-in mic (which is the typical default)
-                let isBuiltIn = newDevice.portType == .builtInMic
-                Logger.debug("AudioDeviceManager", "Reset device is built-in mic: \(isBuiltIn)")
-            } else {
-                Logger.debug("AudioDeviceManager", "No device found after reset")
-            }
-            
-            completion(true, nil)
-        } catch {
-            Logger.debug("AudioDeviceManager", "Failed to reset to default device: \(error.localizedDescription)")
-            completion(false, error)
-        }
-    }
-    
-    /// Starts monitoring device connection/disconnection events
-    private func startMonitoringDeviceChanges() {
-        // Ensure we don't add multiple observers
-        stopMonitoringDeviceChanges()
-
-        Logger.debug("AudioDeviceManager", "Starting device change monitoring")
-        routeChangeObserver = NotificationCenter.default.addObserver(
-            forName: AVAudioSession.routeChangeNotification,
-            object: nil,
-            queue: .main // Process on main queue to avoid threading issues with delegate calls
-        ) { [weak self] notification in
-            self?.handleRouteChange(notification)
-        }
-    }
-
-    /// Stops monitoring device changes
-    private func stopMonitoringDeviceChanges() {
-        if let observer = routeChangeObserver {
-            Logger.debug("AudioDeviceManager", "Stopping device change monitoring")
-            NotificationCenter.default.removeObserver(observer)
-            routeChangeObserver = nil
-        }
-    }
-
-    /// Handles route change notifications to detect device connections and disconnections
-    @objc private func handleRouteChange(_ notification: Notification) {
-        guard let userInfo = notification.userInfo,
-              let reasonValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
-              let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue) else {
-            return
-        }
-
-         Logger.debug("AudioDeviceManager", "Route change detected, reason: \(reason.rawValue)")
-
-        // Only proceed if a device was potentially removed or added or the route changed significantly
-        guard reason == .oldDeviceUnavailable || reason == .newDeviceAvailable || reason == .override || reason == .routeConfigurationChange else {
-             Logger.debug("AudioDeviceManager", "Ignoring route change reason: \(reason.rawValue)")
-            return
-        }
-
-        // Get the *previous* route description
-        guard let previousRoute = userInfo[AVAudioSessionRouteChangePreviousRouteKey] as? AVAudioSessionRouteDescription else {
-            Logger.debug("AudioDeviceManager", "No previous route info found for device change check.")
-            return
-        }
-
-        // Get the *current* available input devices
-        let currentInputs = AVAudioSession.sharedInstance().availableInputs ?? []
-        let currentInputIds = Set(currentInputs.map { normalizeBluetoothDeviceId($0.uid) })
-        let previousInputIds = Set(previousRoute.inputs.map { normalizeBluetoothDeviceId($0.uid) })
-
-                // Check for DISCONNECTED devices (were in previous route but not in current available)
-        for previousInputPort in previousRoute.inputs {
-            let normalizedPreviousId = normalizeBluetoothDeviceId(previousInputPort.uid)
-            if !currentInputIds.contains(normalizedPreviousId) {
-                 Logger.debug("AudioDeviceManager", "Detected disconnection of device: \(previousInputPort.portName) (Normalized ID: \(normalizedPreviousId))")
-                 // Keep existing disconnection delegate method unchanged
-                 delegate?.audioDeviceManager(self, didDetectDisconnectionOfDevice: normalizedPreviousId)
-            }
-        }
-
-        // Check for CONNECTED devices (are in current available but were not in previous route)
-        for currentInput in currentInputs {
-            let normalizedCurrentId = normalizeBluetoothDeviceId(currentInput.uid)
-            if !previousInputIds.contains(normalizedCurrentId) {
-                Logger.debug("AudioDeviceManager", "Detected connection of device: \(currentInput.portName) (Normalized ID: \(normalizedCurrentId))")
-                // Emit connection event via notification
-                NotificationCenter.default.post(
-                    name: NSNotification.Name("DeviceConnected"),
-                    object: nil,
-                    userInfo: ["deviceId": normalizedCurrentId]
-                )
-            }
-        }
-    }
-    
-    /// Normalizes Bluetooth device IDs by removing profile suffixes
-    public func normalizeBluetoothDeviceId(_ deviceId: String) -> String {
-        // For Bluetooth devices with MAC addresses and profile suffixes (like -tsco)
-        if deviceId.contains(":") && deviceId.contains("-") {
-            // Split by the hyphen and take the first part (the MAC address)
-            return deviceId.split(separator: "-").first.map(String.init) ?? deviceId
-        }
-        return deviceId
-    }
-}
-
-// Add structure for AudioDeviceCapabilities if not defined elsewhere
-struct AudioDeviceCapabilities {
-    let sampleRates: [Int]
-    let channelCounts: [Int]
-    let bitDepths: [Int]
-    // Add boolean flags if needed
-}
-
-// Add structure for AudioDevice if not defined elsewhere
-struct AudioDevice {
-    let id: String
-    let name: String
-    let type: String
-    let isDefault: Bool
-    let capabilities: AudioDeviceCapabilities
-    let isAvailable: Bool
-}