@edkimmel/expo-audio-stream 0.4.2 → 0.6.0

package/ios/Microphone.swift

@@ -2,106 +2,142 @@ import AVFoundation
 import ExpoModulesCore
 
 
-class Microphone {
+class Microphone: SharedAudioEngineDelegate {
     weak var delegate: MicrophoneDataDelegate?
-    
-    private var audioEngine: AVAudioEngine!
-    private var audioConverter: AVAudioConverter!
-    private var inputNode: AVAudioInputNode!
-    
+
+    /// The shared engine whose VP-enabled input node this microphone taps.
+    /// Must be set and configured before calling startRecording.
+    weak var sharedAudioEngine: SharedAudioEngine?
+
     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
     private var frequencyBandAnalyzer: FrequencyBandAnalyzer?
     private var frequencyBandConfig: (lowCrossoverHz: Float, highCrossoverHz: Float)?
-    
-    init() {
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(handleRouteChange),
-            name: AVAudioSession.routeChangeNotification,
-            object: nil
-        )
+
+    private var lastIntervalMs: Int = 100
+    private var pendingInterruptionResume: Bool = false
+
+    // ── SharedAudioEngineDelegate ────────────────────────────────────────
+
+    func engineDidRestartAfterRouteChange() {
+        guard isRecording else { return }
+        // Engine restarted in-place; tap was removed on stop — reinstall.
+        do {
+            try installTap(intervalMilliseconds: lastIntervalMs)
+        } catch {
+            Logger.debug("[Microphone] Failed to reinstall tap after route change: \(error)")
+            failRecording(MicrophoneErrorInfo(
+                code: "RESTART_FAILED",
+                message: "Could not reinstall microphone tap after route change: \(error.localizedDescription)",
+                isFatal: true,
+                autoResuming: false
+            ))
+        }
     }
-    
-    /// 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
+
+    func engineDidRebuild() {
+        guard isRecording else { return }
+        // New AVAudioEngine instance — installTap picks up the new inputNode automatically.
+        do {
+            try installTap(intervalMilliseconds: lastIntervalMs)
+        } catch {
+            Logger.debug("[Microphone] Failed to reinstall tap after engine rebuild: \(error)")
+            failRecording(MicrophoneErrorInfo(
+                code: "RESTART_FAILED",
+                message: "Could not reinstall microphone tap after engine rebuild: \(error.localizedDescription)",
+                isFatal: true,
+                autoResuming: false
+            ))
         }
-        
-        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, frequencyBandConfig: self.frequencyBandConfig)
-                }
-            }
-        case .categoryChange:
-            Logger.debug("[Microphone] Audio Session category changed")
-        default:
-            break
+    }
+
+    func audioSessionResumeDenied() {
+        guard isRecording else { return }
+        failRecording(MicrophoneErrorInfo(
+            code: "RESUME_DENIED",
+            message: "System did not permit microphone resume after interruption",
+            isFatal: true,
+            autoResuming: false
+        ))
+    }
+
+    func audioSessionInterruptionBegan() {
+        guard isRecording else { return }
+        pendingInterruptionResume = true
+        delegate?.onMicrophoneError(MicrophoneErrorInfo(
+            code: "INTERRUPTED",
+            message: "Audio session interrupted by system",
+            isFatal: false,
+            autoResuming: true
+        ))
+    }
+
+    func audioSessionInterruptionEnded() {
+        guard pendingInterruptionResume else { return }
+        pendingInterruptionResume = false
+        do {
+            try installTap(intervalMilliseconds: lastIntervalMs)
+        } catch {
+            Logger.debug("[Microphone] Failed to reinstall tap after interruption resume: \(error)")
+            failRecording(MicrophoneErrorInfo(
+                code: "RESUME_FAILED",
+                message: "Could not reinstall microphone tap after interruption: \(error.localizedDescription)",
+                isFatal: true,
+                autoResuming: false
+            ))
         }
     }
-    
+
+    func engineDidDie(reason: String) {
+        guard isRecording else { return }
+        failRecording(MicrophoneErrorInfo(
+            code: "ENGINE_DIED",
+            message: reason,
+            isFatal: true,
+            autoResuming: false
+        ))
+    }
+
+    // ── Core recording API ───────────────────────────────────────────────
+
     func toggleSilence(isSilent: Bool) {
         Logger.debug("[Microphone] toggleSilence")
         self.isSilent = isSilent
     }
-    
+
     func startRecording(settings: RecordingSettings, intervalMilliseconds: Int,
                         frequencyBandConfig: (lowCrossoverHz: Float, highCrossoverHz: Float)? = nil) -> StartRecordingResult? {
         guard !isRecording else {
-            Logger.debug("Debug: Recording is already in progress.")
+            Logger.debug("[Microphone] Recording is already in progress.")
             return StartRecordingResult(error: "Recording is already in progress.")
         }
-        
-        if self.audioEngine == nil {
-            self.audioEngine = AVAudioEngine()
+        guard let shared = sharedAudioEngine, shared.isConfigured, let engine = shared.engine else {
+            Logger.debug("[Microphone] Shared audio engine is not configured.")
+            return StartRecordingResult(error: "Shared audio engine is not configured.")
         }
-        
-        if self.audioEngine != nil && audioEngine.isRunning  {
-            Logger.debug("Debug: Audio engine already running.")
-            audioEngine.stop()
-        }
-       
-        var newSettings = settings  // Make settings mutable
 
+        var newSettings = settings
         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
+        let hardwareFormat = engine.inputNode.inputFormat(forBus: 0)
+        newSettings.sampleRate = hardwareFormat.sampleRate
+        Logger.debug("[Microphone] Hardware sample rate: \(hardwareFormat.sampleRate) Hz, desired: \(settings.sampleRate) Hz")
 
+        recordingSettings = newSettings
         self.frequencyBandConfig = frequencyBandConfig
-        // Analyzer uses the desired (target) sample rate, not hardware rate
+        self.lastIntervalMs = intervalMilliseconds
+
         let targetRate = Int(settings.desiredSampleRate ?? settings.sampleRate)
         let fbConfig = frequencyBandConfig ?? (lowCrossoverHz: Float(300), highCrossoverHz: Float(2000))
         frequencyBandAnalyzer = FrequencyBandAnalyzer(
@@ -110,32 +146,12 @@ class Microphone {
             highCrossoverHz: fbConfig.highCrossoverHz
         )
 
-        // 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
-        }
-        
+        sharedAudioEngine?.addDelegate(self)
         do {
             startTime = Date()
-            try audioEngine.start()
+            try installTap(intervalMilliseconds: intervalMilliseconds)
             isRecording = true
-            Logger.debug("Debug: Recording started successfully.")
+            Logger.debug("[Microphone] Recording started successfully.")
             return StartRecordingResult(
                 fileUri: "",
                 mimeType: mimeType,
@@ -144,46 +160,81 @@ class Microphone {
                 sampleRate: settings.sampleRate
             )
         } catch {
-            Logger.debug("Error: Could not start the audio engine: \(error.localizedDescription)")
+            Logger.debug("[Microphone] Could not start recording: \(error.localizedDescription)")
+            sharedAudioEngine?.removeDelegate(self)
             isRecording = false
-            return StartRecordingResult(error: "Error: Could not start the audio engine: \(error.localizedDescription)")
+            return StartRecordingResult(error: "Could not start recording: \(error.localizedDescription)")
         }
     }
-    
+
     public func stopRecording(resolver promise: Promise?) {
-        guard self.isRecording else {
-            if let promiseResolver = promise {
-                promiseResolver.resolve(nil)
-            }
+        pendingInterruptionResume = false
+        guard isRecording else {
+            promise?.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()
-            frequencyBandAnalyzer = nil
+        isRecording = false
+        isVoiceProcessingEnabled = false
+        sharedAudioEngine?.engine?.inputNode.removeTap(onBus: 0)
+        sharedAudioEngine?.removeDelegate(self)
+        frequencyBandAnalyzer = nil
+        promise?.resolve(nil)
+    }
+
+    // ── Private helpers ──────────────────────────────────────────────────
+
+    private func failRecording(_ error: MicrophoneErrorInfo) {
+        isRecording = false
+        pendingInterruptionResume = false
+        sharedAudioEngine?.engine?.inputNode.removeTap(onBus: 0)
+        sharedAudioEngine?.removeDelegate(self)
+        frequencyBandAnalyzer = nil
+        delegate?.onMicrophoneError(error)
+    }
+
+    private func installTap(intervalMilliseconds: Int) throws {
+        guard let inputNode = sharedAudioEngine?.engine?.inputNode else {
+            throw NSError(domain: "Microphone", code: -1,
+                          userInfo: [NSLocalizedDescriptionKey: "Shared engine input node unavailable"])
         }
 
-        if let promiseResolver = promise {
-            promiseResolver.resolve(nil)
+        // Remove any stale tap before installing — AVAudioEngine crashes if a tap
+        // is already present on the bus. Engine restarts do not guarantee tap removal.
+        inputNode.removeTap(onBus: 0)
+
+        let hardwareFormat = inputNode.inputFormat(forBus: 0)
+        recordingSettings?.sampleRate = hardwareFormat.sampleRate
+
+        let intervalSamples = AVAudioFrameCount(
+            Double(intervalMilliseconds) / 1000.0 * hardwareFormat.sampleRate
+        )
+        let tapBufferSize = max(intervalSamples, 256)
+
+        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("[Microphone] Received empty buffer in tap callback")
+                self.delegate?.onMicrophoneError(MicrophoneErrorInfo(
+                    code: "READ_ERROR",
+                    message: "Received empty audio buffer",
+                    isFatal: false,
+                    autoResuming: false
+                ))
+                return
+            }
+            self.processAudioBuffer(buffer)
+            self.lastBufferTime = time
         }
     }
-    
-    /// 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) {
+            if let resampledBuffer = AudioUtils.resampleAudioBuffer(
+                currentBuffer, from: currentBuffer.format.sampleRate, to: targetSampleRate) {
                 currentBuffer = resampledBuffer
             } else if let convertedBuffer = AudioUtils.tryConvertToFormat(
                 inputBuffer: currentBuffer,
@@ -193,13 +244,12 @@ class Microphone {
             ) {
                 currentBuffer = convertedBuffer
             } else {
-                Logger.debug("Failed to resample audio buffer.")
+                Logger.debug("[Microphone] 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)
@@ -220,13 +270,12 @@ class Microphone {
         } else {
             let audioData = currentBuffer.audioBufferList.pointee.mBuffers
             guard let bufferData = audioData.mData else {
-                Logger.debug("Buffer data is nil.")
+                Logger.debug("[Microphone] Buffer data is nil.")
                 return
             }
             data = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
         }
 
-        // Compute frequency bands from the Int16 PCM data
         let bands: FrequencyBands?
         if isSilent {
             bands = .zero
@@ -238,8 +287,6 @@ class Microphone {
         }
 
         totalDataSize += Int64(data.count)
-
-        // Emit immediately — tap buffer size is already interval-aligned
         self.delegate?.onMicrophoneData(data, powerLevel, bands)
         self.lastEmittedSize = totalDataSize
     }

package/ios/MicrophoneDataDelegate.swift

@@ -1,4 +1,13 @@
+struct MicrophoneErrorInfo {
+    let code: String
+    let message: String
+    /// True when the recording has stopped and the caller must reconnect to resume.
+    let isFatal: Bool
+    /// True only for INTERRUPTED — the library will reinstall the tap automatically.
+    let autoResuming: Bool
+}
+
 protocol MicrophoneDataDelegate: AnyObject {
     func onMicrophoneData(_ microphoneData: Data, _ soundLevel: Float?, _ frequencyBands: FrequencyBands?)
-    func onMicrophoneError(_ error: String, _ errorMessage: String)
+    func onMicrophoneError(_ error: MicrophoneErrorInfo)
 }

package/ios/PipelineIntegration.swift

@@ -20,6 +20,7 @@ class PipelineIntegration: PipelineListener {
     static let EVENT_ZOMBIE_DETECTED     = "PipelineZombieDetected"
     static let EVENT_UNDERRUN            = "PipelineUnderrun"
     static let EVENT_DRAINED             = "PipelineDrained"
+    static let EVENT_PLAYBACK_STOPPED    = "PipelinePlaybackStopped"
     static let EVENT_AUDIO_FOCUS_LOST    = "PipelineAudioFocusLost"
     static let EVENT_AUDIO_FOCUS_RESUMED = "PipelineAudioFocusResumed"
     static let EVENT_FREQUENCY_BANDS    = "PipelineFrequencyBands"
@@ -72,7 +73,7 @@ class PipelineIntegration: PipelineListener {
             sharedEngine: sharedEngine,
             listener: self
         )
-        p.connect()
+        try p.connect()
         pipeline = p
 
         return [
@@ -152,6 +153,11 @@ class PipelineIntegration: PipelineListener {
         return pipeline?.getState().rawValue ?? PipelineState.idle.rawValue
     }
 
+    /// Current platform output latency in milliseconds. Returns 0 if not connected.
+    func outputLatencyMs() -> Double {
+        return pipeline?.outputLatencyMs() ?? 0
+    }
+
     /// 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.
@@ -206,6 +212,10 @@ class PipelineIntegration: PipelineListener {
         sendEvent(PipelineIntegration.EVENT_DRAINED, ["turnId": turnId])
     }
 
+    func onPlaybackStopped(turnId: String) {
+        sendEvent(PipelineIntegration.EVENT_PLAYBACK_STOPPED, ["turnId": turnId])
+    }
+
     func onAudioFocusLost() {
         sendEvent(PipelineIntegration.EVENT_AUDIO_FOCUS_LOST, [:])
     }

package/ios/SharedAudioEngine.swift

@@ -21,12 +21,20 @@ protocol SharedAudioEngineDelegate: AnyObject {
     /// Consumer should restart playback.
     func audioSessionInterruptionEnded()
 
+    /// Audio session interruption ended but the system did not signal shouldResume.
+    /// Recording has been stopped. Consumer should clean up and wait for the user to reconnect.
+    func audioSessionResumeDenied()
+
     /// Engine failed to restart after exhausting all retry attempts.
     /// All state has been torn down. Consumer should report the failure
     /// to JS and clean up its own state so a fresh connect can succeed.
     func engineDidDie(reason: String)
 }
 
+extension SharedAudioEngineDelegate {
+    func audioSessionResumeDenied() {}
+}
+
 /// Owns the single AVAudioEngine shared between AudioPipeline consumers.
 ///
 /// Responsibilities:
@@ -494,6 +502,16 @@ class SharedAudioEngine {
             notifyDelegates { $0.audioSessionInterruptionBegan() }
         } else if type == .ended {
             Logger.debug("[\(SharedAudioEngine.TAG)] Audio session interruption ended")
+            let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt ?? 0
+            let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
+            guard options.contains(.shouldResume) else {
+                // shouldResume absent — system hints we should not restart yet.
+                // Note: this flag is advisory; may be worth revisiting if it causes
+                // false negatives in practice.
+                Logger.debug("[\(SharedAudioEngine.TAG)] shouldResume not set — skipping restart")
+                notifyDelegates { $0.audioSessionResumeDenied() }
+                return
+            }
             // Reactivate session and restart engine
             try? AVAudioSession.sharedInstance().setActive(true)
             if let engine = engine, !engine.isRunning {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edkimmel/expo-audio-stream",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "description": "Expo Play Audio Stream module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -9,7 +9,6 @@
     "build": "expo-module build",
     "clean": "expo-module clean",
     "lint": "expo-module lint",
-    "test": "expo-module test",
     "prepare": "expo-module prepare && husky || true",
     "prepublishOnly": "expo-module prepublishOnly",
     "expo-module": "expo-module",

package/plugin/build/index.js

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_plugins_1 = require("@expo/config-plugins");
 const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone';
+// AVFoundation enumerates AirPlay/Continuity audio devices on the local network
+// even though we don't use them — without this description, iOS shows a generic
+// prompt and a denial leaves the audio session unable to activate.
+const LOCAL_NETWORK_USAGE = 'Allow $(PRODUCT_NAME) to discover audio devices on your local network';
 const withRecordingPermission = (config, existingPerms) => {
     if (!existingPerms) {
         console.warn('No previous permissions provided');
     }
     config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
         config.modResults['NSMicrophoneUsageDescription'] = config.modResults['NSMicrophoneUsageDescription'] || MICROPHONE_USAGE;
+        config.modResults['NSLocalNetworkUsageDescription'] = config.modResults['NSLocalNetworkUsageDescription'] || LOCAL_NETWORK_USAGE;
         // Add audio to UIBackgroundModes to allow background audio recording
         const existingBackgroundModes = config.modResults.UIBackgroundModes || [];
         if (!existingBackgroundModes.includes('audio')) {

package/plugin/src/index.ts

@@ -6,6 +6,10 @@ import {
 } from '@expo/config-plugins'
 
 const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone'
+// AVFoundation enumerates AirPlay/Continuity audio devices on the local network
+// even though we don't use them — without this description, iOS shows a generic
+// prompt and a denial leaves the audio session unable to activate.
+const LOCAL_NETWORK_USAGE = 'Allow $(PRODUCT_NAME) to discover audio devices on your local network'
 
 const withRecordingPermission: ConfigPlugin<{
     microphonePermission: string
@@ -15,6 +19,7 @@ const withRecordingPermission: ConfigPlugin<{
     }
     config = withInfoPlist(config, (config) => {
         config.modResults['NSMicrophoneUsageDescription'] = config.modResults['NSMicrophoneUsageDescription'] || MICROPHONE_USAGE
+        config.modResults['NSLocalNetworkUsageDescription'] = config.modResults['NSLocalNetworkUsageDescription'] || LOCAL_NETWORK_USAGE
 
         // Add audio to UIBackgroundModes to allow background audio recording
         const existingBackgroundModes =

package/src/events.ts

@@ -21,6 +21,10 @@ export interface AudioEventPayload {
   streamUuid: string;
   soundLevel?: number;
   frequencyBands?: { low: number; mid: number; high: number };
+  /** Set by native when a mid-recording error occurs (interruption, read failure).
+   * When present, `encoded` is absent and the recording is no longer active. */
+  error?: string;
+  errorMessage?: string;
 }
 
 export const DeviceReconnectedReasons = {
@@ -38,6 +42,7 @@ export type DeviceReconnectedEventPayload = {
 
 export const AudioEvents = {
   AudioData: "AudioData",
+  MicrophoneError: "MicrophoneError",
   DeviceReconnected: "DeviceReconnected",
 };
 
@@ -47,6 +52,33 @@ export function addAudioEventListener(
   return (emitter as any).addListener("AudioData", listener);
 }
 
+export interface MicrophoneErrorEventPayload {
+  code: string;
+  message: string;
+  isFatal: boolean;
+  autoResuming: boolean;
+}
+
+/**
+ * Subscribe to the dedicated MicrophoneError native event.
+ *
+ * OTA safe: if the running native binary predates this feature, the event is
+ * never emitted and this listener is never called. Apps that also subscribe to
+ * AudioData errors via addAudioEventListener continue to work unchanged.
+ *
+ * @example
+ * const sub = addMicrophoneErrorListener((e) => {
+ *   if (e.isFatal) { stopMicrophone(); reconnect(); }
+ *   else if (e.autoResuming) { showPausedUI(); }
+ * })
+ * // cleanup: sub.remove()
+ */
+export function addMicrophoneErrorListener(
+  listener: (event: MicrophoneErrorEventPayload) => void
+): EventSubscription {
+  return (emitter as any).addListener("MicrophoneError", listener);
+}
+
 export function subscribeToEvent<T extends unknown>(
   eventName: string,
   listener: (event: T | undefined) => Promise<void>