@siteed/expo-audio-stream 2.1.0 → 2.2.0

package/ios/ExpoAudioStreamModule.swift

@@ -1,805 +0,0 @@
-// packages/expo-audio-stream/ios/ExpoAudioStreamModule.swift
-import ExpoModulesCore
-import AVFoundation
-
-let audioDataEvent: String = "AudioData"
-let audioAnalysisEvent: String = "AudioAnalysis"
-let recordingInterruptedEvent: String = "onRecordingInterrupted"
-
-public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
-    private var streamManager = AudioStreamManager()
-    private let notificationCenter = UNUserNotificationCenter.current()
-    private let notificationIdentifier = "audio_recording_notification"
-        
-    public func definition() -> ModuleDefinition {
-        Name("ExpoAudioStream")
-        
-        // Defines event names that the module can send to JavaScript.
-        Events([
-            audioDataEvent,
-            audioAnalysisEvent,
-            recordingInterruptedEvent
-        ])
-        
-        OnCreate {
-            print("Setting streamManager delegate")
-            streamManager.delegate = self
-        }
-        
-        /// Extracts audio analysis data from an audio file.
-        ///
-        /// - Parameters:
-        ///   - options: A dictionary containing:
-        ///     - `fileUri`: The URI of the audio file.
-        ///     - `pointsPerSecond`: The number of data points to extract per second of audio.
-        ///     - `features`: A dictionary specifying which features to extract (e.g., `energy`, `mfcc`, `rms`, etc.).
-        ///   - promise: A promise to resolve with the extracted audio analysis data or reject with an error.
-        /// - Returns: Promise to be resolved with audio analysis data.
-        AsyncFunction("extractAudioAnalysis") { (options: [String: Any], promise: Promise) in
-            guard let fileUri = options["fileUri"] as? String,
-                  let url = URL(string: fileUri) else {
-                promise.reject("INVALID_ARGUMENTS", "Invalid file URI provided")
-                return
-            }
-            
-            // Get time or byte range options
-            let startTimeMs = options["startTimeMs"] as? Double
-            let endTimeMs = options["endTimeMs"] as? Double
-            let position = options["position"] as? Int
-            let byteLength = options["length"] as? Int
-            
-            // Validate ranges - can have time range OR byte range OR no range
-            let hasTimeRange = startTimeMs != nil && endTimeMs != nil
-            let hasByteRange = position != nil && byteLength != nil
-            
-            // Only throw if both ranges are provided
-            guard !(hasTimeRange && hasByteRange) else {
-                promise.reject("INVALID_ARGUMENTS", "Cannot specify both time range and byte range")
-                return
-            }
-            
-            let features = options["features"] as? [String: Bool] ?? [:]
-            let featureOptions = self.extractFeatureOptions(from: features)
-            let segmentDurationMs = options["segmentDurationMs"] as? Int ?? 100 // Default value of 100ms
-            
-            DispatchQueue.global().async(execute: {
-                do {
-                    let audioFile = try AVAudioFile(forReading: url)
-                    let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
-                    let numberOfChannels = Int(audioFile.fileFormat.channelCount)
-                    let sampleRate = audioFile.fileFormat.sampleRate
-                    
-                    // Convert time range to byte range if needed
-                    let effectivePosition: Int?
-                    let effectiveLength: Int?
-                    
-                    if hasTimeRange {
-                        let bytesPerSecond = Int(sampleRate) * numberOfChannels * (bitDepth / 8)
-                        effectivePosition = Int(startTimeMs! * Double(bytesPerSecond) / 1000.0)
-                        effectiveLength = Int((endTimeMs! - startTimeMs!) * Double(bytesPerSecond) / 1000.0)
-                    } else {
-                        effectivePosition = position
-                        effectiveLength = byteLength
-                    }
-                    
-                    let audioProcessor = try AudioProcessor(url: url, resolve: { result in
-                        promise.resolve(result)
-                    }, reject: { code, message in
-                        promise.reject(code, message)
-                    })
-                    
-                    if let result = audioProcessor.processAudioData(
-                        numberOfSamples: nil,
-                        offset: 0,
-                        length: nil,
-                        segmentDurationMs: segmentDurationMs,
-                        featureOptions: featureOptions,
-                        bitDepth: bitDepth,
-                        numberOfChannels: numberOfChannels,
-                        position: effectivePosition,
-                        byteLength: effectiveLength
-                    ) {
-                        promise.resolve(result.toDictionary())
-                    } else {
-                        promise.reject("PROCESSING_ERROR", "Failed to process audio data")
-                    }
-                } catch {
-                    promise.reject("PROCESSING_ERROR", "Failed to initialize audio processor: \(error.localizedDescription)")
-                }
-            })
-        }
-        
-        
-        /// Asynchronously starts audio recording with the given settings.
-        ///
-        /// - Parameters:
-        ///   - options: A dictionary containing:
-        ///     - `sampleRate`: The sample rate for recording (default is 16000.0).
-        ///     - `channelConfig`: The number of channels (default is 1 for mono).
-        ///     - `audioFormat`: The bit depth for recording (default is 16 bits).
-        ///     - `interval`: The interval in milliseconds at which to emit recording data (default is 1000 ms).
-        ///     - `intervalAnalysis`: The interval in milliseconds at which to emit analysis data (default is 500 ms).
-        ///     - `enableProcessing`: Boolean to enable/disable audio processing (default is false).
-        ///     - `pointsPerSecond`: The number of data points to extract per second of audio (default is 20).
-        ///     - `algorithm`: The algorithm to use for extraction (default is "rms").
-        ///     - `featureOptions`: A dictionary of feature options to extract (default is empty).
-        ///     - `maxRecentDataDuration`: The maximum duration of recent data to keep for processing (default is 10.0 seconds).
-        ///     - `compression`: A dictionary containing:
-        ///       - `enabled`: Boolean to enable/disable compression (default is false).
-        ///       - `format`: The compression format (default is "aac").
-        ///       - `bitrate`: The compression bitrate in bps (default is 128000).
-        ///   - promise: A promise to resolve with the recording settings or reject with an error.
-        AsyncFunction("startRecording") { (options: [String: Any], promise: Promise) in
-            self.checkMicrophonePermission { granted in
-                guard granted else {
-                    promise.reject("PERMISSION_DENIED", "Recording permission has not been granted")
-                    return
-                }
-                
-                // Create settings with validation
-                let settingsResult = RecordingSettings.fromDictionary(options)
-                
-                switch settingsResult {
-                case .success(let settings):
-                    // Initialize notification if enabled
-                    if settings.showNotification {
-                        Task {
-                            let notificationGranted = await self.requestNotificationPermissions()
-                            if !notificationGranted {
-                                Logger.debug("Notification permissions not granted")
-                            }
-                        }
-                    }
-                    
-                    if let result = self.streamManager.startRecording(settings: settings) {
-                        var resultDict: [String: Any] = [
-                            "fileUri": result.fileUri,
-                            "channels": result.channels,
-                            "bitDepth": result.bitDepth,
-                            "sampleRate": result.sampleRate,
-                            "mimeType": result.mimeType,
-                        ]
-                        
-                        // Add compression info if available
-                        if let compression = result.compression {
-                            resultDict["compression"] = [
-                                "compressedFileUri": compression.compressedFileUri,
-                                "mimeType": compression.mimeType,
-                                "bitrate": compression.bitrate,
-                                "format": compression.format
-                            ]
-                        }
-                        
-                        promise.resolve(resultDict)
-                    } else {
-                        promise.reject("ERROR", "Failed to start recording.")
-                    }
-                    
-                case .failure(let error):
-                    promise.reject("INVALID_SETTINGS", error.localizedDescription)
-                }
-            }
-        }
-        
-        /// Retrieves the current status of the audio stream.
-        ///
-        /// - Returns: The current status of the audio stream.Ï
-        Function("status") {
-            return self.streamManager.getStatus()
-        }
-        
-        /// Pauses audio recording.
-        Function("pauseRecording") {
-            self.streamManager.pauseRecording()
-        }
-        
-        /// Resumes audio recording.
-        Function("resumeRecording") {
-            self.streamManager.resumeRecording()
-        }
-        
-        /// Asynchronously stops audio recording and retrieves the recording result.
-        ///
-        /// - Parameters:
-        ///   - promise: A promise to resolve with the recording result or reject with an error.
-        AsyncFunction("stopRecording") { (promise: Promise) in
-            if let recordingResult = self.streamManager.stopRecording() {
-                var resultDict: [String: Any] = [
-                    "fileUri": recordingResult.fileUri,
-                    "filename": recordingResult.filename,
-                    "durationMs": recordingResult.duration,
-                    "size": recordingResult.size,
-                    "channels": recordingResult.channels,
-                    "bitDepth": recordingResult.bitDepth,
-                    "sampleRate": recordingResult.sampleRate,
-                    "mimeType": recordingResult.mimeType,
-                    "createdAt": Date().timeIntervalSince1970 * 1000,
-                ]
-                
-                // Add compression info if available
-                if let compression = recordingResult.compression {
-                    resultDict["compression"] = [
-                        "compressedFileUri": compression.compressedFileUri,
-                        "mimeType": compression.mimeType,
-                        "bitrate": compression.bitrate,
-                        "format": compression.format,
-                        "size": compression.size
-                    ]
-                }
-                
-                promise.resolve(resultDict)
-            } else {
-                promise.reject("ERROR", "Failed to stop recording or no recording in progress.")
-            }
-        }
-        
-        /// Asynchronously lists all audio files stored in the document directory.
-        ///
-        /// - Parameters:
-        ///   - promise: A promise to resolve with the list of audio file URIs or reject with an error.
-        /// - Returns: A promise that resolves with the list of audio file URIs or rejects with an error.
-        AsyncFunction("listAudioFiles") { (promise: Promise) in
-            let files = listAudioFiles()
-            promise.resolve(files)
-        }
-        
-        /// Clears all audio files stored in the document directory.
-        Function("clearAudioFiles") {
-            clearAudioFiles()
-        }
-        
-        
-        /// Requests audio recording permissions.
-        ///
-        /// - Parameters:
-        ///   - promise: A promise to resolve with the permission status or reject with an error.
-        /// - Returns: Promise to be resolved with the permission status.
-        AsyncFunction("requestPermissionsAsync") { (promise: Promise) in
-            AVAudioSession.sharedInstance().requestRecordPermission { granted in
-                promise.resolve([
-                    "status": granted ? "granted" : "denied",
-                    "granted": granted,
-                    "expires": "never",
-                    "canAskAgain": true
-                ])
-            }
-        }
-        
-        AsyncFunction("requestNotificationPermissionsAsync") { (promise: Promise) in
-            Task {
-                let granted = await requestNotificationPermissions()
-                promise.resolve([
-                    "granted": granted,
-                    "status": granted ? "granted" : "denied"
-                ])
-            }
-        }
-        
-        /// Gets the current audio recording permissions.
-        ///
-        /// - Parameters:
-        ///   - promise: A promise to resolve with the permission status or reject with an error.
-        /// - Returns: Promise to be resolved with the permission status.
-        AsyncFunction("getPermissionsAsync") { (promise: Promise) in
-            let permissionStatus = AVAudioSession.sharedInstance().recordPermission
-            switch permissionStatus {
-            case .granted:
-                promise.resolve([
-                    "status": "granted",
-                    "granted": true,
-                    "expires": "never",
-                    "canAskAgain": true
-                ])
-            case .denied:
-                promise.resolve([
-                    "status": "denied",
-                    "granted": false,
-                    "expires": "never",
-                    "canAskAgain": false
-                ])
-            case .undetermined:
-                promise.resolve([
-                    "status": "undetermined",
-                    "granted": false,
-                    "expires": "never",
-                    "canAskAgain": true
-                ])
-            @unknown default:
-                promise.reject("UNKNOWN_ERROR", "Unknown permission status")
-            }
-        }
-
-        /// Trims an audio file to specified start and end times.
-        /// - Parameters:
-        ///   - options: A dictionary containing:
-        ///     - `fileUri`: The URI of the audio file.
-        ///     - `mode`: Trim mode ('single', 'keep', or 'remove').
-        ///     - `startTimeMs`: Start time in milliseconds (for 'single' mode).
-        ///     - `endTimeMs`: End time in milliseconds (for 'single' mode).
-        ///     - `ranges`: Array of time ranges (for 'keep' and 'remove' modes).
-        ///     - `outputFileName`: Optional name for the output file.
-        ///     - `outputFormat`: Optional output format configuration.
-        ///     - `decodingOptions`: Optional decoding configuration.
-        AsyncFunction("trimAudio") { (options: [String: Any], promise: Promise) in
-            guard let fileUri = options["fileUri"] as? String,
-                  let url = URL(string: fileUri) else {
-                promise.reject("INVALID_ARGUMENTS", "Invalid file URI provided")
-                return
-            }
-
-            let mode = options["mode"] as? String ?? "single"
-            let startTimeMs = options["startTimeMs"] as? Double
-            let endTimeMs = options["endTimeMs"] as? Double
-            let ranges = options["ranges"] as? [[String: Double]]
-            let outputFileName = options["outputFileName"] as? String
-            let outputFormat = options["outputFormat"] as? [String: Any]
-            let decodingOptions = options["decodingOptions"] as? [String: Any]
-
-            // Add detailed logging for filename and format options
-            Logger.debug("Trim audio request:")
-            Logger.debug("- Input file: \(fileUri)")
-            Logger.debug("- Mode: \(mode)")
-            Logger.debug("- Output filename: \(outputFileName ?? "not specified (will generate UUID)")")
-            if let format = outputFormat?["format"] as? String {
-                Logger.debug("- Output format: \(format)")
-            } else {
-                Logger.debug("- Output format: not specified (will use default)")
-            }
-
-            // Input validation based on mode
-            switch mode {
-            case "single":
-                guard let start = startTimeMs, let end = endTimeMs else {
-                    promise.reject("INVALID_ARGUMENTS", "startTimeMs and endTimeMs required for 'single' mode")
-                    return
-                }
-                guard start >= 0, end > start else {
-                    promise.reject("INVALID_ARGUMENTS", "Invalid time range")
-                    return
-                }
-            case "keep", "remove":
-                guard let rangesArray = ranges, !rangesArray.isEmpty else {
-                    promise.reject("INVALID_ARGUMENTS", "'ranges' array required for 'keep' or 'remove' mode")
-                    return
-                }
-            default:
-                promise.reject("INVALID_MODE", "Mode must be 'single', 'keep', or 'remove'")
-                return
-            }
-
-            DispatchQueue.global().async {
-                do {
-                    let audioProcessor = try AudioProcessor(
-                        url: url,
-                        resolve: { result in promise.resolve(result) },
-                        reject: { code, message in promise.reject(code, message) }
-                    )
-
-                    let progressCallback: (Float, Int64, Int64) -> Void = { progress, bytesProcessed, totalBytes in
-                        self.sendEvent("TrimProgress", [
-                            "progress": progress,
-                            "bytesProcessed": bytesProcessed,
-                            "totalBytes": totalBytes
-                        ])
-                    }
-
-                    let startTime = CACurrentMediaTime()
-                    if let result = audioProcessor.trimAudio(
-                        mode: mode,
-                        startTimeMs: startTimeMs,
-                        endTimeMs: endTimeMs,
-                        ranges: ranges,
-                        outputFileName: outputFileName,
-                        outputFormat: outputFormat,
-                        decodingOptions: decodingOptions,
-                        progressCallback: progressCallback
-                    ) {
-                        let processingTimeMs = Int((CACurrentMediaTime() - startTime) * 1000)
-                        var resultDict = result.toDictionary()
-                        resultDict["processingInfo"] = ["durationMs": processingTimeMs]
-                        
-                        let uri = result.uri
-                        Logger.debug("Trim completed successfully in \(processingTimeMs)ms")
-                        Logger.debug("Output file URI: \(uri)")
-                        
-                        // Verify file exists
-                        let fileManager = FileManager.default
-                        if let url = URL(string: uri) {
-                            let exists = fileManager.fileExists(atPath: url.path)
-                            Logger.debug("File exists at path \(url.path): \(exists)")
-                            
-                            // Log filename details
-                            Logger.debug("Filename: \(url.lastPathComponent)")
-                            Logger.debug("File extension: \(url.pathExtension.lowercased())")
-                            
-                            // If format is AAC, ensure we're using the correct extension and MIME type
-                            if let format = outputFormat?["format"] as? String, 
-                               format.lowercased() == "aac" {
-                                
-                                Logger.debug("AAC format detected - ensuring correct metadata")
-                                
-                                // For AAC format, ensure we're using the correct extension and MIME type
-                                if url.pathExtension.lowercased() == "m4a" {
-                                    Logger.debug("File has correct m4a extension for AAC audio")
-                                    
-                                    // Just update the MIME type in the result to ensure correct playback
-                                    if var compression = resultDict["compression"] as? [String: Any] {
-                                        compression["mimeType"] = "audio/mp4"
-                                        resultDict["compression"] = compression
-                                    }
-                                    
-                                    resultDict["mimeType"] = "audio/mp4"
-                                    resultDict["actualFormat"] = "m4a"
-                                } else {
-                                    Logger.debug("Warning: AAC format should use .m4a extension, but found .\(url.pathExtension.lowercased())")
-                                }
-                            }
-                        }
-                        
-                        promise.resolve(resultDict)
-                    } else {
-                        Logger.debug("Failed to trim audio")
-                        promise.reject("TRIM_ERROR", "Failed to trim audio")
-                    }
-                } catch {
-                    Logger.debug("Failed to initialize audio processor: \(error.localizedDescription)")
-                    promise.reject("PROCESSING_ERROR", "Failed to initialize audio processor: \(error.localizedDescription)")
-                }
-            }
-        }
-        
-        /// Extracts raw PCM audio data from a file with time or byte range support
-        /// - Parameters:
-        ///   - options: A dictionary containing:
-        ///     - `fileUri`: The URI of the audio file
-        ///     - `startTimeMs`: Optional start time in milliseconds
-        ///     - `endTimeMs`: Optional end time in milliseconds
-        ///     - `position`: Optional byte position
-        ///     - `length`: Optional byte length
-        ///     - `includeNormalizedData`: Boolean to include normalized audio data in [-1, 1] range
-        ///     - `includeWavHeader`: Boolean to include WAV header in the PCM data
-        ///     - `decodingOptions`: Decoding configuration
-        ///     - `includeBase64Data`: Boolean to include base64 encoded string representation of the audio data
-        ///     - `computeChecksum`: Boolean to compute and include CRC32 checksum of the PCM data
-        AsyncFunction("extractAudioData") { (options: [String: Any], promise: Promise) in
-            guard let fileUri = options["fileUri"] as? String,
-                  let url = URL(string: fileUri) else {
-                promise.reject("INVALID_ARGUMENTS", "Invalid file URI provided")
-                return
-            }
-
-            // Get time or byte range options
-            let startTimeMs = options["startTimeMs"] as? Double
-            let endTimeMs = options["endTimeMs"] as? Double
-            let position = options["position"] as? Int
-            let length = options["length"] as? Int
-            let includeWavHeader = options["includeWavHeader"] as? Bool ?? false
-
-            // Validate that we have either time range or byte range, but not both and not neither
-            let hasTimeRange = startTimeMs != nil && endTimeMs != nil
-            let hasByteRange = position != nil && length != nil
-
-            guard hasTimeRange || hasByteRange else {
-                promise.reject("INVALID_ARGUMENTS", "Must specify either time range (startTimeMs, endTimeMs) or byte range (position, length)")
-                return
-            }
-
-            guard !(hasTimeRange && hasByteRange) else {
-                promise.reject("INVALID_ARGUMENTS", "Cannot specify both time range and byte range")
-                return
-            }
-
-            do {
-                let audioFile = try AVAudioFile(forReading: url)
-                let format = audioFile.processingFormat
-                let sampleRate = format.sampleRate
-                let channels = Int(format.channelCount)
-                let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
-
-                // Calculate frame positions
-                let startFrame: AVAudioFramePosition
-                let endFrame: AVAudioFramePosition
-
-                if hasTimeRange {
-                    startFrame = AVAudioFramePosition(startTimeMs! * sampleRate / 1000.0)
-                    endFrame = AVAudioFramePosition(endTimeMs! * sampleRate / 1000.0)
-                } else {
-                    // Convert byte position to frame position
-                    let bytesPerFrame = Int64(channels * (bitDepth / 8))
-                    startFrame = AVAudioFramePosition(position!) / bytesPerFrame
-                    endFrame = startFrame + (AVAudioFramePosition(length!) / bytesPerFrame)
-                }
-
-                // Validate frame range
-                guard startFrame >= 0 && endFrame <= audioFile.length && startFrame < endFrame else {
-                    promise.reject("INVALID_RANGE", "Invalid range specified")
-                    return
-                }
-
-                let frameCount = AVAudioFrameCount(endFrame - startFrame)
-                
-                // Create decoding config that includes normalization preference
-                var decodingOptions = options["decodingOptions"] as? [String: Any] ?? [:]
-                let includeNormalizedData = options["includeNormalizedData"] as? Bool ?? false
-                
-                // Pass both options separately - normalizeAudio from decodingOptions, and includeNormalizedData as is
-                let decodingConfig = DecodingConfig.fromDictionary(decodingOptions)
-                
-                let (pcmData, normalizedData, base64Data) = try extractRawAudioData(
-                    from: url,
-                    startFrame: startFrame,
-                    frameCount: frameCount,
-                    format: format,
-                    decodingConfig: decodingConfig,
-                    includeNormalizedData: includeNormalizedData,
-                    includeBase64Data: options["includeBase64Data"] as? Bool ?? false
-                )
-
-                var resultDict: [String: Any] = [:]
-                
-                if includeWavHeader {
-                    // Create WAV header and prepend it to the PCM data
-                    let wavData = createWavHeader(
-                        pcmData: pcmData,
-                        sampleRate: Int(sampleRate),
-                        channels: channels,
-                        bitDepth: bitDepth
-                    )
-                    resultDict["pcmData"] = wavData
-                    resultDict["hasWavHeader"] = true
-                } else {
-                    resultDict["pcmData"] = pcmData
-                    resultDict["hasWavHeader"] = false
-                }
-                
-                // Add the rest of the data
-                resultDict["sampleRate"] = Int(sampleRate)
-                resultDict["channels"] = channels
-                resultDict["bitDepth"] = bitDepth
-                resultDict["durationMs"] = Int(Double(frameCount) * 1000.0 / sampleRate)
-                resultDict["format"] = "pcm_\(bitDepth)bit"
-                resultDict["samples"] = Int(frameCount) * channels
-                
-                // Add normalized data if requested, regardless of normalization setting
-                if includeNormalizedData {
-                    resultDict["normalizedData"] = normalizedData
-                }
-                
-                // Add checksum if requested
-                if options["computeChecksum"] as? Bool == true {
-                    let checksum = calculateCRC32(data: pcmData)
-                    resultDict["checksum"] = Int(checksum)
-                    
-                    Logger.debug("Computed CRC32 checksum: \(checksum)")
-                }
-                
-                if let includeBase64Data = options["includeBase64Data"] as? Bool, includeBase64Data {
-                    resultDict["base64Data"] = base64Data
-                }
-                
-                promise.resolve(resultDict)
-
-            } catch {
-                promise.reject("PROCESSING_ERROR", "Failed to process audio file: \(error.localizedDescription)")
-            }
-        }
-        
-        /// Extracts mel spectrogram data from a file.
-        ///
-        /// - Parameters:
-        ///   - options: A dictionary containing:
-        ///     - `fileUri`: The URI of the audio file.
-        ///     - `pointsPerSecond`: The number of data points to extract per second of audio.
-        ///   - promise: A promise to resolve with the extracted mel spectrogram data or reject with an error.
-        /// - Returns: Promise to be resolved with mel spectrogram data.
-        AsyncFunction("extractMelSpectrogram") { (options: [String: Any], promise: Promise) in
-            // This is a placeholder implementation that will be fully implemented later
-            // Currently, mel spectrogram extraction is only available on Android
-            promise.reject(
-                "UNSUPPORTED_PLATFORM", 
-                "Mel spectrogram extraction is currently only available on Android and is experimental"
-            )
-        }
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didReceiveInterruption info: [String: Any]) {
-        // Convert iOS interruption events to match the TypeScript types
-        var reason: String
-        var isPaused: Bool = true
-        
-        if let type = info["type"] as? String {
-            switch type {
-            case "began":
-                // Phone call or other audio session interruption began
-                reason = "audioFocusLoss"
-            case "ended":
-                reason = "audioFocusGain"
-                isPaused = false
-                // Check if this was from a phone call
-                if let wasSuspended = info["wasSuspended"] as? Bool, wasSuspended {
-                    reason = "phoneCallEnded"
-                }
-            default:
-                return
-            }
-        } else if let specificReason = info["reason"] as? String {
-            // Handle specific reasons that are already properly formatted
-            reason = specificReason
-            isPaused = info["isPaused"] as? Bool ?? true
-        } else {
-            return
-        }
-        
-        // Send event in the correct format
-        sendEvent(recordingInterruptedEvent, [
-            "reason": reason,
-            "isPaused": isPaused,
-            "timestamp": Date().timeIntervalSince1970 * 1000
-        ])
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didPauseRecording pauseTime: Date) {
-        sendEvent(recordingInterruptedEvent, [
-            "reason": "userPaused",
-            "isPaused": true,
-            "timestamp": pauseTime.timeIntervalSince1970 * 1000
-        ])
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didResumeRecording resumeTime: Date) {
-        sendEvent(recordingInterruptedEvent, [
-            "reason": "userResumed",
-            "isPaused": false,
-            "timestamp": resumeTime.timeIntervalSince1970 * 1000
-        ])
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didUpdateNotificationState isPaused: Bool) {
-        sendEvent(recordingInterruptedEvent, [
-            "reason": "notification",
-            "isPaused": isPaused,
-            "timestamp": Date().timeIntervalSince1970 * 1000
-        ])
-    }
-    
-    /// Handles the reception of audio data from the AudioStreamManager.
-    ///
-    /// - Parameters:
-    ///   - manager: The AudioStreamManager instance.
-    ///   - data: The received audio data.
-    ///   - recordingTime: The current recording time.
-    ///   - totalDataSize: The total size of the received audio data.
-    func audioStreamManager(
-        _ manager: AudioStreamManager,
-        didReceiveAudioData data: Data,
-        recordingTime: TimeInterval,
-        totalDataSize: Int64,
-        compressionInfo: [String: Any]?
-    ) {
-        var resultDict: [String: Any] = [
-            "fileUri": manager.recordingFileURL?.absoluteString ?? "",
-            "lastEmittedSize": totalDataSize,
-            "encoded": data.base64EncodedString(),
-            "deltaSize": data.count,
-            "position": Int64(recordingTime * 1000),
-            "mimeType": manager.mimeType,
-            "totalSize": totalDataSize,
-            "streamUuid": manager.recordingUUID?.uuidString ?? UUID().uuidString
-        ]
-        
-        if let compressionInfo = compressionInfo {
-            resultDict["compression"] = compressionInfo
-        }
-        
-        sendEvent(audioDataEvent, resultDict)
-    }
-    
-    private func requestNotificationPermissions() async -> Bool {
-        do {
-            let options: UNAuthorizationOptions = [.alert, .sound]
-            return try await notificationCenter.requestAuthorization(options: options)
-        } catch {
-            Logger.debug("Failed to request notification permissions: \(error)")
-            return false
-        }
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didReceiveProcessingResult result: AudioAnalysisData?) {
-        // Handle the processed audio data
-        // Emit the processing result event to JavaScript
-        let resultDict = result?.toDictionary() ?? [:]
-        Logger.debug("emitting \(audioAnalysisEvent) event with \(resultDict)")
-        sendEvent(audioAnalysisEvent, resultDict)
-    }
-    
-    /// Checks microphone permission and calls the completion handler with the result.
-    ///
-    /// - Parameters:
-    ///   - completion: A completion handler that receives a boolean indicating whether the microphone permission was granted.
-    private func checkMicrophonePermission(completion: @escaping (Bool) -> Void) {
-        switch AVAudioSession.sharedInstance().recordPermission {
-        case .granted:
-            completion(true)
-        case .denied:
-            completion(false)
-        case .undetermined:
-            AVAudioSession.sharedInstance().requestRecordPermission { granted in
-                DispatchQueue.main.async {
-                    completion(granted)
-                }
-            }
-        @unknown default:
-            completion(false)
-        }
-    }
-    
-    /// Clears all audio files stored in the document directory.
-    private func clearAudioFiles() {
-        let fileURLs = listAudioFiles()  // This now returns full URLs as strings
-        fileURLs.forEach { fileURLString in
-            if let fileURL = URL(string: fileURLString) {
-                do {
-                    try FileManager.default.removeItem(at: fileURL)
-                    print("Removed file at:", fileURL.path)
-                } catch {
-                    print("Error removing file at \(fileURL.path):", error.localizedDescription)
-                }
-            } else {
-                print("Invalid URL string: \(fileURLString)")
-            }
-        }
-    }
-    
-    /// Extracts feature options from the provided options dictionary.
-    ///
-    /// - Parameters:
-    ///   - options: The options dictionary containing feature flags.
-    /// - Returns: A dictionary with feature flags and their boolean values.
-    private func extractFeatureOptions(from options: [String: Any]) -> [String: Bool] {
-        return [
-            "energy": options["energy"] as? Bool ?? false,
-            "mfcc": options["mfcc"] as? Bool ?? false,
-            "rms": options["rms"] as? Bool ?? false,
-            "zcr": options["zcr"] as? Bool ?? false,
-            "dB": options["dB"] as? Bool ?? false,
-            "spectralCentroid": options["spectralCentroid"] as? Bool ?? false,
-            "spectralFlatness": options["spectralFlatness"] as? Bool ?? false,
-            "spectralRollOff": options["spectralRollOff"] as? Bool ?? false,
-            "spectralBandwidth": options["spectralBandwidth"] as? Bool ?? false,
-            "chromagram": options["chromagram"] as? Bool ?? false,
-            "tempo": options["tempo"] as? Bool ?? false,
-            "hnr": options["hnr"] as? Bool ?? false,
-            "melSpectrogram": options["melSpectrogram"] as? Bool ?? false,
-            "spectralContrast": options["spectralContrast"] as? Bool ?? false,
-            "tonnetz": options["tonnetz"] as? Bool ?? false,
-            "pitch": options["pitch"] as? Bool ?? false,
-            "crc32": options["crc32"] as? Bool ?? false
-        ]
-    }
-    
-    /// Lists all audio files stored in the document directory.
-    ///
-    /// - Returns: An array of file URIs as strings.
-    func listAudioFiles() -> [String] {
-        guard let documentDirectory = try? FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false) else {
-            print("Failed to access document directory.")
-            return []
-        }
-        
-        do {
-            let files = try FileManager.default.contentsOfDirectory(at: documentDirectory, includingPropertiesForKeys: nil)
-            let audioFiles = files.filter { $0.pathExtension == "wav" }.map { $0.absoluteString }
-            return audioFiles
-        } catch {
-            print("Error listing audio files:", error.localizedDescription)
-            return []
-        }
-    }
-    
-    func audioStreamManager(_ manager: AudioStreamManager, didFailWithError error: String) {
-        // Send error event to JavaScript
-        sendEvent("error", [
-            "message": error
-        ])
-    }
-}