@edkimmel/expo-audio-stream 0.2.0

package/ios/Microphone.swift

@@ -0,0 +1,221 @@
+import AVFoundation
+import ExpoModulesCore
+
+
+class Microphone {
+    weak var delegate: MicrophoneDataDelegate?
+    
+    private var audioEngine: AVAudioEngine!
+    private var audioConverter: AVAudioConverter!
+    private var inputNode: AVAudioInputNode!
+    
+    public private(set) var isVoiceProcessingEnabled: Bool = false
+    
+    
+    internal var lastEmittedSize: Int64 = 0
+    private var totalDataSize: Int64 = 0
+    internal var recordingSettings: RecordingSettings?
+
+    internal var mimeType: String = "audio/wav"
+    private var lastBufferTime: AVAudioTime?
+    
+    private var startTime: Date?
+    private var pauseStartTime: Date?
+    
+
+    private var inittedAudioSession = false
+    private var isRecording: Bool = false
+    private var isSilent: Bool = false
+    
+    init() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleRouteChange),
+            name: AVAudioSession.routeChangeNotification,
+            object: nil
+        )
+    }
+    
+    /// Handles audio route changes (e.g. headphones connected/disconnected)
+    /// - Parameter notification: The notification object containing route change information
+    @objc private func handleRouteChange(notification: Notification) {
+        guard let info = notification.userInfo,
+              let reasonValue = info[AVAudioSessionRouteChangeReasonKey] as? UInt,
+              let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue) else {
+            return
+        }
+        
+        Logger.debug("[Microphone] Route is changed \(reason)")
+
+        switch reason {
+        case .newDeviceAvailable, .oldDeviceUnavailable:
+            if isRecording {
+                stopRecording(resolver: nil)
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                    guard let self = self, let settings = self.recordingSettings else { return }
+                    
+                    _ = startRecording(settings: self.recordingSettings!, intervalMilliseconds: 100)
+                }
+            }
+        case .categoryChange:
+            Logger.debug("[Microphone] Audio Session category changed")
+        default:
+            break
+        }
+    }
+    
+    func toggleSilence(isSilent: Bool) {
+        Logger.debug("[Microphone] toggleSilence")
+        self.isSilent = isSilent
+    }
+    
+    func startRecording(settings: RecordingSettings, intervalMilliseconds: Int) -> StartRecordingResult? {
+        guard !isRecording else {
+            Logger.debug("Debug: Recording is already in progress.")
+            return StartRecordingResult(error: "Recording is already in progress.")
+        }
+        
+        if self.audioEngine == nil {
+            self.audioEngine = AVAudioEngine()
+        }
+        
+        if self.audioEngine != nil && audioEngine.isRunning  {
+            Logger.debug("Debug: Audio engine already running.")
+            audioEngine.stop()
+        }
+       
+        var newSettings = settings  // Make settings mutable
+
+        totalDataSize = 0
+        
+        // Use the hardware's native format for the tap to avoid Core Audio format mismatch crashes.
+        // The inputNode delivers audio in the hardware format (e.g. 48kHz Float32).
+        // Resampling and format conversion to the desired settings happens in processAudioBuffer.
+        let hardwareFormat = audioEngine.inputNode.inputFormat(forBus: 0)
+        newSettings.sampleRate = hardwareFormat.sampleRate
+        Logger.debug("Debug: Hardware sample rate is \(hardwareFormat.sampleRate) Hz, desired sample rate is \(settings.sampleRate) Hz")
+
+        recordingSettings = newSettings  // Update the class property with the new settings
+
+        // Compute tap buffer size from interval so Core Audio delivers at the right cadence
+        let intervalSamples = AVAudioFrameCount(
+            Double(intervalMilliseconds) / 1000.0 * hardwareFormat.sampleRate
+        )
+        let tapBufferSize = max(intervalSamples, 256) // floor at 256 frames (~5ms at 48kHz)
+
+        // Pass nil for format to use the hardware's native format, avoiding format mismatch crashes.
+        // Core Audio does not support format conversion (e.g. Float32 -> Int16) on the tap itself.
+        audioEngine.inputNode.installTap(onBus: 0, bufferSize: tapBufferSize, format: nil) { [weak self] (buffer, time) in
+            guard let self = self else { return }
+
+            guard buffer.frameLength > 0 else {
+                Logger.debug("Error: received empty buffer in tap callback")
+                self.delegate?.onMicrophoneError("READ_ERROR", "Received empty audio buffer")
+                return
+            }
+
+            self.processAudioBuffer(buffer)
+            self.lastBufferTime = time
+        }
+        
+        do {
+            startTime = Date()
+            try audioEngine.start()
+            isRecording = true
+            Logger.debug("Debug: Recording started successfully.")
+            return StartRecordingResult(
+                fileUri: "",
+                mimeType: mimeType,
+                channels: settings.numberOfChannels,
+                bitDepth: settings.bitDepth,
+                sampleRate: settings.sampleRate
+            )
+        } catch {
+            Logger.debug("Error: Could not start the audio engine: \(error.localizedDescription)")
+            isRecording = false
+            return StartRecordingResult(error: "Error: Could not start the audio engine: \(error.localizedDescription)")
+        }
+    }
+    
+    public func stopRecording(resolver promise: Promise?) {
+        guard self.isRecording else {
+            if let promiseResolver = promise {
+                promiseResolver.resolve(nil)
+            }
+            return
+        }
+        self.isRecording = false
+        self.isVoiceProcessingEnabled = false
+       
+        // Remove tap before stopping the engine
+        if audioEngine != nil {
+            audioEngine.inputNode.removeTap(onBus: 0)
+            audioEngine.stop()
+        }
+        
+        if let promiseResolver = promise {
+            promiseResolver.resolve(nil)
+        }
+    }
+    
+    /// Processes the audio buffer and writes data to the file. Also handles audio processing if enabled.
+    /// - Parameters:
+    ///   - buffer: The audio buffer to process.
+    ///   - fileURL: The URL of the file to write the data to.
+    private func processAudioBuffer(_ buffer: AVAudioPCMBuffer) {
+        let targetSampleRate = recordingSettings?.desiredSampleRate ?? buffer.format.sampleRate
+        let targetBitDepth = recordingSettings?.bitDepth ?? 16
+        var currentBuffer = buffer
+
+        // Resample if needed
+        if currentBuffer.format.sampleRate != targetSampleRate {
+            if let resampledBuffer = AudioUtils.resampleAudioBuffer(currentBuffer, from: currentBuffer.format.sampleRate, to: targetSampleRate) {
+                currentBuffer = resampledBuffer
+            } else if let convertedBuffer = AudioUtils.tryConvertToFormat(
+                inputBuffer: currentBuffer,
+                desiredSampleRate: targetSampleRate,
+                desiredChannel: 1,
+                bitDepth: targetBitDepth
+            ) {
+                currentBuffer = convertedBuffer
+            } else {
+                Logger.debug("Failed to resample audio buffer.")
+            }
+        }
+
+        let powerLevel: Float = self.isSilent ? -160.0 : AudioUtils.calculatePowerLevel(from: currentBuffer)
+
+        // Convert Float32 → Int16 PCM if needed (the tap delivers hardware-native Float32)
+        let data: Data
+        if isSilent {
+            let byteCount = Int(currentBuffer.frameCapacity) * Int(currentBuffer.format.streamDescription.pointee.mBytesPerFrame)
+            data = Data(repeating: 0, count: byteCount)
+        } else if targetBitDepth == 16 && currentBuffer.format.commonFormat == .pcmFormatFloat32,
+                  let floatData = currentBuffer.floatChannelData {
+            let frameCount = Int(currentBuffer.frameLength)
+            let channelCount = Int(currentBuffer.format.channelCount)
+            var int16Data = Data(capacity: frameCount * channelCount * 2)
+            for frame in 0..<frameCount {
+                for ch in 0..<channelCount {
+                    let sample = max(-1.0, min(1.0, floatData[ch][frame]))
+                    var int16Sample = Int16(sample * 32767.0)
+                    int16Data.append(Data(bytes: &int16Sample, count: 2))
+                }
+            }
+            data = int16Data
+        } else {
+            let audioData = currentBuffer.audioBufferList.pointee.mBuffers
+            guard let bufferData = audioData.mData else {
+                Logger.debug("Buffer data is nil.")
+                return
+            }
+            data = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
+        }
+
+        totalDataSize += Int64(data.count)
+
+        // Emit immediately — tap buffer size is already interval-aligned
+        self.delegate?.onMicrophoneData(data, powerLevel)
+        self.lastEmittedSize = totalDataSize
+    }
+}

package/ios/MicrophoneDataDelegate.swift

@@ -0,0 +1,4 @@
+protocol MicrophoneDataDelegate: AnyObject {
+    func onMicrophoneData(_ microphoneData: Data, _ soundLevel: Float?)
+    func onMicrophoneError(_ error: String, _ errorMessage: String)
+}

package/ios/PipelineIntegration.swift

@@ -0,0 +1,214 @@
+import Foundation
+
+/// Protocol for sending pipeline events to the Expo module (analogous to Android's EventSender).
+protocol PipelineEventSender: AnyObject {
+    func sendPipelineEvent(_ eventName: String, _ params: [String: Any])
+}
+
+/// Bridge layer wiring AudioPipeline into ExpoPlayAudioStreamModule.
+///
+/// Holds the pipeline instance, implements PipelineListener to forward native events
+/// as Expo bridge events, and exposes the 7 bridge methods that the module's
+/// definition() block declares.
+class PipelineIntegration: PipelineListener {
+    private static let TAG = "PipelineIntegration"
+
+    // ── Event name constants (match the TS PipelineEventMap keys) ─────
+    static let EVENT_STATE_CHANGED       = "PipelineStateChanged"
+    static let EVENT_PLAYBACK_STARTED    = "PipelinePlaybackStarted"
+    static let EVENT_ERROR               = "PipelineError"
+    static let EVENT_ZOMBIE_DETECTED     = "PipelineZombieDetected"
+    static let EVENT_UNDERRUN            = "PipelineUnderrun"
+    static let EVENT_DRAINED             = "PipelineDrained"
+    static let EVENT_AUDIO_FOCUS_LOST    = "PipelineAudioFocusLost"
+    static let EVENT_AUDIO_FOCUS_RESUMED = "PipelineAudioFocusResumed"
+
+    private weak var eventSender: PipelineEventSender?
+    private weak var sharedEngine: SharedAudioEngine?
+    private var pipeline: AudioPipeline?
+
+    init(eventSender: PipelineEventSender, sharedEngine: SharedAudioEngine) {
+        self.eventSender = eventSender
+        self.sharedEngine = sharedEngine
+    }
+
+    // ════════════════════════════════════════════════════════════════════
+    // Bridge methods
+    // ════════════════════════════════════════════════════════════════════
+
+    /// Connect the pipeline. Creates a new AudioPipeline with the given options.
+    ///
+    /// Options:
+    ///   - `sampleRate` (Int, default 24000)
+    ///   - `channelCount` (Int, default 1)
+    ///   - `targetBufferMs` (Int, default 80)
+    ///
+    /// Returns a dictionary with the resolved config on success.
+    func connect(options: [String: Any]) throws -> [String: Any] {
+        // Tear down any existing pipeline first
+        pipeline?.disconnect()
+
+        guard let sharedEngine = sharedEngine else {
+            throw NSError(domain: "PipelineIntegration", code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "SharedAudioEngine not set"])
+        }
+
+        let sampleRate = (options["sampleRate"] as? NSNumber)?.intValue ?? 24000
+        let channelCount = (options["channelCount"] as? NSNumber)?.intValue ?? 1
+        let targetBufferMs = (options["targetBufferMs"] as? NSNumber)?.intValue ?? 80
+
+        let p = AudioPipeline(
+            sampleRate: sampleRate,
+            channelCount: channelCount,
+            targetBufferMs: targetBufferMs,
+            sharedEngine: sharedEngine,
+            listener: self
+        )
+        p.connect()
+        pipeline = p
+
+        return [
+            "sampleRate": sampleRate,
+            "channelCount": channelCount,
+            "targetBufferMs": targetBufferMs,
+            "frameSizeSamples": p.frameSizeSamples
+        ]
+    }
+
+    /// Push base64-encoded PCM audio into the jitter buffer (async path).
+    ///
+    /// Options:
+    ///   - `audio` (String) — base64-encoded PCM16 LE data
+    ///   - `turnId` (String) — conversation turn identifier
+    ///   - `isFirstChunk` (Boolean, default false)
+    ///   - `isLastChunk` (Boolean, default false)
+    func pushAudio(options: [String: Any]) throws {
+        guard let audio = options["audio"] as? String else {
+            throw NSError(domain: "PipelineIntegration", code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Missing 'audio' field"])
+        }
+        guard let turnId = options["turnId"] as? String else {
+            throw NSError(domain: "PipelineIntegration", code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Missing 'turnId' field"])
+        }
+        let isFirstChunk = options["isFirstChunk"] as? Bool ?? false
+        let isLastChunk = options["isLastChunk"] as? Bool ?? false
+
+        guard let p = pipeline else {
+            throw NSError(domain: "PipelineIntegration", code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Pipeline not connected"])
+        }
+        p.pushAudio(base64Audio: audio, turnId: turnId, isFirstChunk: isFirstChunk, isLastChunk: isLastChunk)
+    }
+
+    /// Push base64-encoded PCM audio synchronously (no Promise overhead).
+    /// Returns true on success, false on failure.
+    func pushAudioSync(options: [String: Any]) -> Bool {
+        guard let audio = options["audio"] as? String,
+              let turnId = options["turnId"] as? String else {
+            return false
+        }
+        let isFirstChunk = options["isFirstChunk"] as? Bool ?? false
+        let isLastChunk = options["isLastChunk"] as? Bool ?? false
+
+        guard let p = pipeline else { return false }
+        p.pushAudio(base64Audio: audio, turnId: turnId, isFirstChunk: isFirstChunk, isLastChunk: isLastChunk)
+        return true
+    }
+
+    /// Disconnect the pipeline. Tears down AVAudioEngine, timers, etc.
+    func disconnect() {
+        pipeline?.disconnect()
+        pipeline = nil
+    }
+
+    /// Invalidate the current turn — discards stale audio in the jitter buffer.
+    ///
+    /// Options:
+    ///   - `turnId` (String) — the new turn identifier
+    func invalidateTurn(options: [String: Any]) throws {
+        guard let turnId = options["turnId"] as? String else {
+            throw NSError(domain: "PipelineIntegration", code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Missing 'turnId' field"])
+        }
+        pipeline?.invalidateTurn(newTurnId: turnId)
+    }
+
+    /// Get current pipeline telemetry as a dictionary (returned to JS as a map).
+    func getTelemetry() -> [String: Any] {
+        return pipeline?.getTelemetry() ?? ["state": PipelineState.idle.rawValue]
+    }
+
+    /// Get current pipeline state string.
+    func getState() -> String {
+        return pipeline?.getState().rawValue ?? PipelineState.idle.rawValue
+    }
+
+    /// Register the pipeline as a delegate on the shared engine.
+    /// Called by the module after connect() so route changes and interruptions
+    /// are forwarded to the AudioPipeline instance.
+    func setAsActiveDelegate(on engine: SharedAudioEngine) {
+        if let p = pipeline {
+            engine.addDelegate(p)
+        }
+    }
+
+    /// Remove the pipeline delegate from the shared engine.
+    /// Called by the module before disconnect so stale callbacks aren't delivered.
+    func removeAsDelegate(from engine: SharedAudioEngine) {
+        if let p = pipeline {
+            engine.removeDelegate(p)
+        }
+    }
+
+    /// Destroy the integration — called from module destroy().
+    func destroy() {
+        if let p = pipeline, let engine = sharedEngine {
+            engine.removeDelegate(p)
+        }
+        pipeline?.disconnect()
+        pipeline = nil
+    }
+
+    // ════════════════════════════════════════════════════════════════════
+    // PipelineListener implementation → Expo bridge events
+    // ════════════════════════════════════════════════════════════════════
+
+    func onStateChanged(_ state: PipelineState) {
+        sendEvent(PipelineIntegration.EVENT_STATE_CHANGED, ["state": state.rawValue])
+    }
+
+    func onPlaybackStarted(turnId: String) {
+        sendEvent(PipelineIntegration.EVENT_PLAYBACK_STARTED, ["turnId": turnId])
+    }
+
+    func onError(code: String, message: String) {
+        sendEvent(PipelineIntegration.EVENT_ERROR, ["code": code, "message": message])
+    }
+
+    func onZombieDetected(stalledMs: Int64) {
+        sendEvent(PipelineIntegration.EVENT_ZOMBIE_DETECTED, ["stalledMs": stalledMs])
+    }
+
+    func onUnderrun(count: Int) {
+        sendEvent(PipelineIntegration.EVENT_UNDERRUN, ["count": count])
+    }
+
+    func onDrained(turnId: String) {
+        sendEvent(PipelineIntegration.EVENT_DRAINED, ["turnId": turnId])
+    }
+
+    func onAudioFocusLost() {
+        sendEvent(PipelineIntegration.EVENT_AUDIO_FOCUS_LOST, [:])
+    }
+
+    func onAudioFocusResumed() {
+        sendEvent(PipelineIntegration.EVENT_AUDIO_FOCUS_RESUMED, [:])
+    }
+
+    // ── Helper ────────────────────────────────────────────────────────
+
+    private func sendEvent(_ eventName: String, _ params: [String: Any]) {
+        eventSender?.sendPipelineEvent(eventName, params)
+    }
+}

package/ios/RecordingResult.swift

@@ -0,0 +1,10 @@
+// RecordingResult.swift
+
+struct StartRecordingResult {
+    var fileUri: String?
+    var mimeType: String?
+    var channels: Int?
+    var bitDepth: Int?
+    var sampleRate: Double?
+    var error: String?
+}

package/ios/RecordingSettings.swift

@@ -0,0 +1,11 @@
+// RecordingSettings.swift
+
+struct RecordingSettings {
+    var sampleRate: Double
+    var desiredSampleRate: Double
+    var numberOfChannels: Int = 1
+    var bitDepth: Int = 16
+    var maxRecentDataDuration: Double? = 10.0 // Default to 10 seconds
+    var pointsPerSecond: Int? = 1000 // Default value
+}
+