@edkimmel/expo-audio-stream 0.6.1 → 0.6.3

package/android/src/main/java/expo/modules/audiostream/AudioRecorderManager.kt

@@ -36,6 +36,7 @@ class AudioRecorderManager(
 
     // Flag to control whether actual audio data or silence is sent
     private var isSilent = false
+    @Volatile private var micGain: Float = 1.0f
     private var frequencyBandAnalyzer: FrequencyBandAnalyzer? = null
     private val gainNormalizer = GainNormalizer()
 
@@ -154,9 +155,10 @@ class AudioRecorderManager(
         // Generate a unique ID for this recording stream
         streamUuid = java.util.UUID.randomUUID().toString()
 
-        audioRecord?.startRecording()
-        // Apply audio effects after starting recording using the manager
+        // AEC and other effects must be attached before startRecording() so the
+        // hardware echo canceller processes audio from the very first captured frame.
         audioRecord?.let { audioEffectsManager.setupAudioEffects(it) }
+        audioRecord?.startRecording()
 
         isPaused.set(false)
         isRecording.set(true)
@@ -385,8 +387,11 @@ class AudioRecorderManager(
     }
 
     private fun emitAudioData(audioData: ByteArray, length: Int) {
-        // If silent mode is active, replace audioData with zeros (using concise expression)
-        val dataToEncode = if (isSilent) ByteArray(length) else audioData
+        val dataToEncode = when {
+            isSilent -> ByteArray(length)
+            micGain != 1.0f -> applyMicGain(audioData, length, micGain)
+            else -> audioData
+        }
 
         val encodedBuffer = audioDataEncoder.encodeToBase64(dataToEncode)
 
@@ -471,6 +476,25 @@ class AudioRecorderManager(
     /**
      * Toggles between sending actual audio data and silence
      */
+    fun setMicrophoneGain(gain: Float) {
+        micGain = gain.coerceIn(0.0f, 1.0f)
+    }
+
+    private fun applyMicGain(data: ByteArray, length: Int, gain: Float): ByteArray {
+        val result = ByteArray(length)
+        var i = 0
+        while (i + 1 < length) {
+            val lo = data[i].toInt() and 0xFF
+            val hi = data[i + 1].toInt()       // sign-extends
+            val sample = (hi shl 8) or lo      // little-endian Int16
+            val scaled = (sample * gain).toInt().coerceIn(-32768, 32767)
+            result[i]     = (scaled and 0xFF).toByte()
+            result[i + 1] = (scaled shr 8).toByte()
+            i += 2
+        }
+        return result
+    }
+
     fun toggleSilence(isSilent: Boolean) {
         this.isSilent = isSilent
         Log.d(Constants.TAG, "Silence mode toggled: $isSilent")

package/android/src/main/java/expo/modules/audiostream/ExpoPlayAudioStreamModule.kt

@@ -168,10 +168,13 @@ class ExpoPlayAudioStreamModule : Module(), EventSender {
         }
 
         Function("toggleSilence") { isSilent: Boolean ->
-            // Just toggle silence without returning any value
             audioRecorderManager.toggleSilence(isSilent)
         }
 
+        Function("setMicrophoneGain") { gain: Double ->
+            audioRecorderManager.setMicrophoneGain(gain.toFloat())
+        }
+
         // ── Native Audio Pipeline V3 ────────────────────────────────────
 
         AsyncFunction("connectPipeline") { options: Map<String, Any?>, promise: Promise ->

package/build/index.d.ts

@@ -50,6 +50,11 @@ export declare class ExpoPlayAudioStream {
      * @throws {Error} If the microphone fails to toggle silence.
      */
     static toggleSilence(isSilent: boolean): void;
+    /**
+     * Sets the microphone capture gain (0.0 = silent, 1.0 = full).
+     * Takes effect immediately on the next captured audio chunk.
+     */
+    static setMicrophoneGain(gain: number): void;
     /**
      * Requests microphone permission from the user.
      * @returns {Promise<{granted: boolean, canAskAgain?: boolean, status?: string}>} A promise that resolves to the permission result.

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/build/index.js

@@ -124,6 +124,13 @@ export class ExpoPlayAudioStream {
     static toggleSilence(isSilent) {
         ExpoPlayAudioStreamModule.toggleSilence(isSilent);
     }
+    /**
+     * Sets the microphone capture gain (0.0 = silent, 1.0 = full).
+     * Takes effect immediately on the next captured audio chunk.
+     */
+    static setMicrophoneGain(gain) {
+        ExpoPlayAudioStreamModule.setMicrophoneGain(Math.max(0, Math.min(1, gain)));
+    }
     /**
      * Requests microphone permission from the user.
      * @returns {Promise<{granted: boolean, canAskAgain?: boolean, status?: string}>} A promise that resolves to the permission result.

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,yBAAyB,MAAM,6BAA6B,CAAC;AAIpE,OAAO,EAOL,aAAa,EAEb,aAAa,GAcd,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAE1B,WAAW,EACX,gBAAgB,GAGjB,MAAM,UAAU,CAAC;AAElB,MAAM,OAAO,mBAAmB;IAC9B;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO;QAClB,MAAM,yBAAyB,CAAC,OAAO,EAAE,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,eAAgC;QAI3D,IAAI,YAAsC,CAAC;QAC3C,IAAI,CAAC;YACH,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,eAAe,CAAC;YAE/D,MAAM,aAAa,GAAwB,EAAE,CAAC;YAE9C,IAAI,aAAa,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE,CAAC;gBACzD,aAAa,CAAC,IAAI,CAChB,qBAAqB,CAAC,KAAK,EAAE,KAAwB,EAAE,EAAE;oBACvD,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;oBACtG,sEAAsE;oBACtE,sEAAsE;oBACtE,yEAAyE;oBACzE,gDAAgD;oBAChD,IAAI,KAAK,IAAI,OAAO;wBAAE,OAAO;oBAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;wBACb,OAAO,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;wBACrE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;oBACnD,CAAC;oBACD,aAAa,CAAC;wBACZ,IAAI,EAAE,OAAO;wBACb,QAAQ;wBACR,OAAO;wBACP,aAAa,EAAE,SAAS;wBACxB,SAAS;wBACT,UAAU;wBACV,cAAc;qBACf,CAAC,CAAC;gBACL,CAAC,CAAC,CACH,CAAC;YACJ,CAAC;YAED,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;gBAC7C,aAAa,CAAC,IAAI,CAChB,0BAA0B,CAAC,CAAC,KAAK,EAAE,EAAE;oBACnC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACjB,CAAC,CAAC,CACH,CAAC;YACJ,CAAC;YAED,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC7B,YAAY,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;YAC5E,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,yBAAyB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAExE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC;QACnD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrB,YAAY,EAAE,MAAM,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,8BAA8B,KAAK,EAAE,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,cAAc;QACzB,IAAI,CAAC;YACH,OAAO,MAAM,yBAAyB,CAAC,cAAc,EAAE,CAAC;QAC1D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,8BAA8B,KAAK,EAAE,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,sBAAsB,CAC3B,kBAA4D;QAE5D,OAAO,qBAAqB,CAAC,KAAK,EAAE,KAAwB,EAAE,EAAE;YAC9D,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,GACpF,KAAK,CAAC;YACR,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;gBACrE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;YACnD,CAAC;YACD,kBAAkB,EAAE,CAAC;gBACnB,IAAI,EAAE,OAAO;gBACb,QAAQ;gBACR,OAAO;gBACP,aAAa,EAAE,SAAS;gBACxB,SAAS;gBACT,UAAU;gBACV,cAAc;aACf,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CACd,SAAiB,EACjB,OAAgD;QAEhD,OAAO,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,qBAAqB;QAC1B,yBAAyB,CAAC,qBAAqB,EAAE,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,aAAa,CAAC,QAAiB;QACpC,yBAAyB,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,uBAAuB;QAKlC,IAAI,CAAC;YACH,OAAO,MAAM,yBAAyB,CAAC,uBAAuB,EAAE,CAAC;QACnE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,kCAAkC,KAAK,EAAE,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB;QAK9B,IAAI,CAAC;YACH,OAAO,MAAM,yBAAyB,CAAC,mBAAmB,EAAE,CAAC;QAC/D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,8BAA8B,KAAK,EAAE,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;CACF;AAED,OAAO,EAOL,WAAW,EAGX,aAAa,EAEb,aAAa,GAcd,CAAC;AAKF,OAAO,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAGtD,kCAAkC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC","sourcesContent":["import type { EventSubscription } from \"expo-modules-core\";\nimport ExpoPlayAudioStreamModule from \"./ExpoPlayAudioStreamModule\";\n\n// Type alias for backwards compatibility\ntype Subscription = EventSubscription;\nimport {\n  AudioDataEvent,\n  AudioRecording,\n  RecordingConfig,\n  StartRecordingResult,\n  PlaybackMode,\n  Encoding,\n  EncodingTypes,\n  FrequencyBands,\n  PlaybackModes,\n  // Audio jitter buffer types\n  IAudioBufferConfig,\n  IAudioPlayPayload,\n  IAudioFrame,\n  BufferHealthState,\n  IBufferHealthMetrics,\n  IAudioBufferManager,\n  IFrameProcessor,\n  IQualityMonitor,\n  BufferedStreamConfig,\n  SmartBufferConfig,\n  SmartBufferMode,\n  NetworkConditions,\n} from \"./types\";\n\nimport {\n  addAudioEventListener,\n  addMicrophoneErrorListener,\n  AudioEventPayload,\n  AudioEvents,\n  subscribeToEvent,\n  DeviceReconnectedReason,\n  DeviceReconnectedEventPayload,\n} from \"./events\";\n\nexport class ExpoPlayAudioStream {\n  /**\n   * Destroys the audio stream module, cleaning up all resources.\n   * This should be called when the module is no longer needed.\n   * It will reset all internal state and release audio resources.\n   */\n  static async destroy() {\n    await ExpoPlayAudioStreamModule.destroy();\n  }\n\n  /**\n   * Starts microphone streaming.\n   * @param {RecordingConfig} recordingConfig - The recording configuration.\n   * @returns {Promise<{recordingResult: StartRecordingResult, subscription: Subscription}>} A promise that resolves to an object containing the recording result and a subscription to audio events.\n   * @throws {Error} If the recording fails to start.\n   */\n  static async startMicrophone(recordingConfig: RecordingConfig): Promise<{\n    recordingResult: StartRecordingResult;\n    subscription?: Subscription;\n  }> {\n    let subscription: Subscription | undefined;\n    try {\n      const { onAudioStream, onError, ...options } = recordingConfig;\n\n      const subscriptions: EventSubscription[] = [];\n\n      if (onAudioStream && typeof onAudioStream === \"function\") {\n        subscriptions.push(\n          addAudioEventListener(async (event: AudioEventPayload) => {\n            const { fileUri, deltaSize, totalSize, position, encoded, soundLevel, frequencyBands, error } = event;\n            // Only suppress AudioData error events when onError is wired up — the\n            // MicrophoneError subscription will handle them. Without onError (old\n            // integration or old native binary), fall through so the missing-encoded\n            // path below preserves the pre-v0.6.0 behavior.\n            if (error && onError) return;\n            if (!encoded) {\n              console.error(`[ExpoPlayAudioStream] Encoded audio data is missing`);\n              throw new Error(\"Encoded audio data is missing\");\n            }\n            onAudioStream({\n              data: encoded,\n              position,\n              fileUri,\n              eventDataSize: deltaSize,\n              totalSize,\n              soundLevel,\n              frequencyBands,\n            });\n          })\n        );\n      }\n\n      if (onError && typeof onError === \"function\") {\n        subscriptions.push(\n          addMicrophoneErrorListener((event) => {\n            onError(event);\n          })\n        );\n      }\n\n      if (subscriptions.length > 0) {\n        subscription = { remove: () => subscriptions.forEach((s) => s.remove()) };\n      }\n\n      const result = await ExpoPlayAudioStreamModule.startMicrophone(options);\n\n      return { recordingResult: result, subscription };\n    } catch (error) {\n      console.error(error);\n      subscription?.remove();\n      throw new Error(`Failed to start recording: ${error}`);\n    }\n  }\n\n  /**\n   * Stops the current microphone streaming.\n   * @returns {Promise<void>}\n   * @throws {Error} If the microphone streaming fails to stop.\n   */\n  static async stopMicrophone(): Promise<AudioRecording | null> {\n    try {\n      return await ExpoPlayAudioStreamModule.stopMicrophone();\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Failed to stop mic stream: ${error}`);\n    }\n  }\n\n  /**\n   * Subscribes to audio events emitted during recording/streaming.\n   * @param onMicrophoneStream - Callback function that will be called when audio data is received.\n   * @returns {Subscription} A subscription object that can be used to unsubscribe from the events\n   */\n  static subscribeToAudioEvents(\n    onMicrophoneStream: (event: AudioDataEvent) => Promise<void>\n  ): Subscription {\n    return addAudioEventListener(async (event: AudioEventPayload) => {\n      const { fileUri, deltaSize, totalSize, position, encoded, soundLevel, frequencyBands } =\n        event;\n      if (!encoded) {\n        console.error(`[ExpoPlayAudioStream] Encoded audio data is missing`);\n        throw new Error(\"Encoded audio data is missing\");\n      }\n      onMicrophoneStream?.({\n        data: encoded,\n        position,\n        fileUri,\n        eventDataSize: deltaSize,\n        totalSize,\n        soundLevel,\n        frequencyBands,\n      });\n    });\n  }\n\n  /**\n   * Subscribes to events emitted by the audio stream module, for advanced use cases.\n   * @param eventName - The name of the event to subscribe to.\n   * @param onEvent - Callback function that will be called when the event is emitted.\n   * @returns {Subscription} A subscription object that can be used to unsubscribe from the events.\n   */\n  static subscribe<T extends unknown>(\n    eventName: string,\n    onEvent: (event: T | undefined) => Promise<void>\n  ): Subscription {\n    return subscribeToEvent(eventName, onEvent);\n  }\n\n  /**\n   * Prompts the user to select the microphone mode.\n   * @returns {Promise<void>}\n   * @throws {Error} If the microphone mode fails to prompt.\n   */\n  static promptMicrophoneModes() {\n    ExpoPlayAudioStreamModule.promptMicrophoneModes();\n  }\n\n  /**\n   * Toggles the silence state of the microphone.\n   * @returns {Promise<void>}\n   * @throws {Error} If the microphone fails to toggle silence.\n   */\n  static toggleSilence(isSilent: boolean) {\n    ExpoPlayAudioStreamModule.toggleSilence(isSilent);\n  }\n\n  /**\n   * Requests microphone permission from the user.\n   * @returns {Promise<{granted: boolean, canAskAgain?: boolean, status?: string}>} A promise that resolves to the permission result.\n   */\n  static async requestPermissionsAsync(): Promise<{\n    granted: boolean;\n    canAskAgain?: boolean;\n    status?: string;\n  }> {\n    try {\n      return await ExpoPlayAudioStreamModule.requestPermissionsAsync();\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Failed to request permissions: ${error}`);\n    }\n  }\n\n  /**\n   * Gets the current microphone permission status.\n   * @returns {Promise<{granted: boolean, canAskAgain?: boolean, status?: string}>} A promise that resolves to the permission status.\n   */\n  static async getPermissionsAsync(): Promise<{\n    granted: boolean;\n    canAskAgain?: boolean;\n    status?: string;\n  }> {\n    try {\n      return await ExpoPlayAudioStreamModule.getPermissionsAsync();\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Failed to get permissions: ${error}`);\n    }\n  }\n}\n\nexport {\n  AudioDataEvent,\n  DeviceReconnectedReason,\n  DeviceReconnectedEventPayload,\n  AudioRecording,\n  RecordingConfig,\n  StartRecordingResult,\n  AudioEvents,\n  PlaybackMode,\n  Encoding,\n  EncodingTypes,\n  FrequencyBands,\n  PlaybackModes,\n  // Audio jitter buffer types\n  IAudioBufferConfig,\n  IAudioPlayPayload,\n  IAudioFrame,\n  BufferHealthState,\n  IBufferHealthMetrics,\n  IAudioBufferManager,\n  IFrameProcessor,\n  IQualityMonitor,\n  BufferedStreamConfig,\n  SmartBufferConfig,\n  SmartBufferMode,\n  NetworkConditions,\n};\n\n// Re-export Subscription type for backwards compatibility\nexport type { EventSubscription } from \"expo-modules-core\";\nexport type { Subscription } from \"./events\";\nexport { addMicrophoneErrorListener } from \"./events\";\nexport type { MicrophoneErrorEventPayload } from \"./events\";\n\n// Export native audio pipeline V3\nexport { Pipeline } from \"./pipeline\";\nexport type {\n  ConnectPipelineOptions,\n  ConnectPipelineResult,\n  PushPipelineAudioOptions,\n  InvalidatePipelineTurnOptions,\n  PipelineState,\n  PipelineEventMap,\n  PipelineEventName,\n  PipelineBufferTelemetry,\n  PipelineTelemetry,\n  PipelineStateChangedEvent,\n  PipelinePlaybackStartedEvent,\n  PipelineErrorEvent,\n  PipelineZombieDetectedEvent,\n  PipelineUnderrunEvent,\n  PipelineDrainedEvent,\n  PipelinePlaybackStoppedEvent,\n  PipelineAudioFocusLostEvent,\n  PipelineAudioFocusResumedEvent,\n} from \"./pipeline\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { EventSubscription } from \"expo-modules-core\";\nimport ExpoPlayAudioStreamModule from \"./ExpoPlayAudioStreamModule\";\n\n// Type alias for backwards compatibility\ntype Subscription = EventSubscription;\nimport {\n  AudioDataEvent,\n  AudioRecording,\n  RecordingConfig,\n  StartRecordingResult,\n  PlaybackMode,\n  Encoding,\n  EncodingTypes,\n  FrequencyBands,\n  PlaybackModes,\n  // Audio jitter buffer types\n  IAudioBufferConfig,\n  IAudioPlayPayload,\n  IAudioFrame,\n  BufferHealthState,\n  IBufferHealthMetrics,\n  IAudioBufferManager,\n  IFrameProcessor,\n  IQualityMonitor,\n  BufferedStreamConfig,\n  SmartBufferConfig,\n  SmartBufferMode,\n  NetworkConditions,\n} from \"./types\";\n\nimport {\n  addAudioEventListener,\n  addMicrophoneErrorListener,\n  AudioEventPayload,\n  AudioEvents,\n  subscribeToEvent,\n  DeviceReconnectedReason,\n  DeviceReconnectedEventPayload,\n} from \"./events\";\n\nexport class ExpoPlayAudioStream {\n  /**\n   * Destroys the audio stream module, cleaning up all resources.\n   * This should be called when the module is no longer needed.\n   * It will reset all internal state and release audio resources.\n   */\n  static async destroy() {\n    await ExpoPlayAudioStreamModule.destroy();\n  }\n\n  /**\n   * Starts microphone streaming.\n   * @param {RecordingConfig} recordingConfig - The recording configuration.\n   * @returns {Promise<{recordingResult: StartRecordingResult, subscription: Subscription}>} A promise that resolves to an object containing the recording result and a subscription to audio events.\n   * @throws {Error} If the recording fails to start.\n   */\n  static async startMicrophone(recordingConfig: RecordingConfig): Promise<{\n    recordingResult: StartRecordingResult;\n    subscription?: Subscription;\n  }> {\n    let subscription: Subscription | undefined;\n    try {\n      const { onAudioStream, onError, ...options } = recordingConfig;\n\n      const subscriptions: EventSubscription[] = [];\n\n      if (onAudioStream && typeof onAudioStream === \"function\") {\n        subscriptions.push(\n          addAudioEventListener(async (event: AudioEventPayload) => {\n            const { fileUri, deltaSize, totalSize, position, encoded, soundLevel, frequencyBands, error } = event;\n            // Only suppress AudioData error events when onError is wired up — the\n            // MicrophoneError subscription will handle them. Without onError (old\n            // integration or old native binary), fall through so the missing-encoded\n            // path below preserves the pre-v0.6.0 behavior.\n            if (error && onError) return;\n            if (!encoded) {\n              console.error(`[ExpoPlayAudioStream] Encoded audio data is missing`);\n              throw new Error(\"Encoded audio data is missing\");\n            }\n            onAudioStream({\n              data: encoded,\n              position,\n              fileUri,\n              eventDataSize: deltaSize,\n              totalSize,\n              soundLevel,\n              frequencyBands,\n            });\n          })\n        );\n      }\n\n      if (onError && typeof onError === \"function\") {\n        subscriptions.push(\n          addMicrophoneErrorListener((event) => {\n            onError(event);\n          })\n        );\n      }\n\n      if (subscriptions.length > 0) {\n        subscription = { remove: () => subscriptions.forEach((s) => s.remove()) };\n      }\n\n      const result = await ExpoPlayAudioStreamModule.startMicrophone(options);\n\n      return { recordingResult: result, subscription };\n    } catch (error) {\n      console.error(error);\n      subscription?.remove();\n      throw new Error(`Failed to start recording: ${error}`);\n    }\n  }\n\n  /**\n   * Stops the current microphone streaming.\n   * @returns {Promise<void>}\n   * @throws {Error} If the microphone streaming fails to stop.\n   */\n  static async stopMicrophone(): Promise<AudioRecording | null> {\n    try {\n      return await ExpoPlayAudioStreamModule.stopMicrophone();\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Failed to stop mic stream: ${error}`);\n    }\n  }\n\n  /**\n   * Subscribes to audio events emitted during recording/streaming.\n   * @param onMicrophoneStream - Callback function that will be called when audio data is received.\n   * @returns {Subscription} A subscription object that can be used to unsubscribe from the events\n   */\n  static subscribeToAudioEvents(\n    onMicrophoneStream: (event: AudioDataEvent) => Promise<void>\n  ): Subscription {\n    return addAudioEventListener(async (event: AudioEventPayload) => {\n      const { fileUri, deltaSize, totalSize, position, encoded, soundLevel, frequencyBands } =\n        event;\n      if (!encoded) {\n        console.error(`[ExpoPlayAudioStream] Encoded audio data is missing`);\n        throw new Error(\"Encoded audio data is missing\");\n      }\n      onMicrophoneStream?.({\n        data: encoded,\n        position,\n        fileUri,\n        eventDataSize: deltaSize,\n        totalSize,\n        soundLevel,\n        frequencyBands,\n      });\n    });\n  }\n\n  /**\n   * Subscribes to events emitted by the audio stream module, for advanced use cases.\n   * @param eventName - The name of the event to subscribe to.\n   * @param onEvent - Callback function that will be called when the event is emitted.\n   * @returns {Subscription} A subscription object that can be used to unsubscribe from the events.\n   */\n  static subscribe<T extends unknown>(\n    eventName: string,\n    onEvent: (event: T | undefined) => Promise<void>\n  ): Subscription {\n    return subscribeToEvent(eventName, onEvent);\n  }\n\n  /**\n   * Prompts the user to select the microphone mode.\n   * @returns {Promise<void>}\n   * @throws {Error} If the microphone mode fails to prompt.\n   */\n  static promptMicrophoneModes() {\n    ExpoPlayAudioStreamModule.promptMicrophoneModes();\n  }\n\n  /**\n   * Toggles the silence state of the microphone.\n   * @returns {Promise<void>}\n   * @throws {Error} If the microphone fails to toggle silence.\n   */\n  static toggleSilence(isSilent: boolean) {\n    ExpoPlayAudioStreamModule.toggleSilence(isSilent);\n  }\n\n  /**\n   * Sets the microphone capture gain (0.0 = silent, 1.0 = full).\n   * Takes effect immediately on the next captured audio chunk.\n   */\n  static setMicrophoneGain(gain: number) {\n    ExpoPlayAudioStreamModule.setMicrophoneGain(Math.max(0, Math.min(1, gain)));\n  }\n\n  /**\n   * Requests microphone permission from the user.\n   * @returns {Promise<{granted: boolean, canAskAgain?: boolean, status?: string}>} A promise that resolves to the permission result.\n   */\n  static async requestPermissionsAsync(): Promise<{\n    granted: boolean;\n    canAskAgain?: boolean;\n    status?: string;\n  }> {\n    try {\n      return await ExpoPlayAudioStreamModule.requestPermissionsAsync();\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Failed to request permissions: ${error}`);\n    }\n  }\n\n  /**\n   * Gets the current microphone permission status.\n   * @returns {Promise<{granted: boolean, canAskAgain?: boolean, status?: string}>} A promise that resolves to the permission status.\n   */\n  static async getPermissionsAsync(): Promise<{\n    granted: boolean;\n    canAskAgain?: boolean;\n    status?: string;\n  }> {\n    try {\n      return await ExpoPlayAudioStreamModule.getPermissionsAsync();\n    } catch (error) {\n      console.error(error);\n      throw new Error(`Failed to get permissions: ${error}`);\n    }\n  }\n}\n\nexport {\n  AudioDataEvent,\n  DeviceReconnectedReason,\n  DeviceReconnectedEventPayload,\n  AudioRecording,\n  RecordingConfig,\n  StartRecordingResult,\n  AudioEvents,\n  PlaybackMode,\n  Encoding,\n  EncodingTypes,\n  FrequencyBands,\n  PlaybackModes,\n  // Audio jitter buffer types\n  IAudioBufferConfig,\n  IAudioPlayPayload,\n  IAudioFrame,\n  BufferHealthState,\n  IBufferHealthMetrics,\n  IAudioBufferManager,\n  IFrameProcessor,\n  IQualityMonitor,\n  BufferedStreamConfig,\n  SmartBufferConfig,\n  SmartBufferMode,\n  NetworkConditions,\n};\n\n// Re-export Subscription type for backwards compatibility\nexport type { EventSubscription } from \"expo-modules-core\";\nexport type { Subscription } from \"./events\";\nexport { addMicrophoneErrorListener } from \"./events\";\nexport type { MicrophoneErrorEventPayload } from \"./events\";\n\n// Export native audio pipeline V3\nexport { Pipeline } from \"./pipeline\";\nexport type {\n  ConnectPipelineOptions,\n  ConnectPipelineResult,\n  PushPipelineAudioOptions,\n  InvalidatePipelineTurnOptions,\n  PipelineState,\n  PipelineEventMap,\n  PipelineEventName,\n  PipelineBufferTelemetry,\n  PipelineTelemetry,\n  PipelineStateChangedEvent,\n  PipelinePlaybackStartedEvent,\n  PipelineErrorEvent,\n  PipelineZombieDetectedEvent,\n  PipelineUnderrunEvent,\n  PipelineDrainedEvent,\n  PipelinePlaybackStoppedEvent,\n  PipelineAudioFocusLostEvent,\n  PipelineAudioFocusResumedEvent,\n} from \"./pipeline\";\n"]}

package/ios/AudioPipeline.swift

@@ -69,9 +69,19 @@ class AudioPipeline: SharedAudioEngineDelegate {
     private var outputFormat: AVAudioFormat?
     private var jitterBuffer: JitterBuffer?
 
-    /// Number of interleaved Int16 samples per scheduled buffer.
+    /// Number of interleaved Int16 samples read from the JitterBuffer per scheduled buffer
+    /// (at pipeline sample rate, e.g. 16 kHz).
     let frameSizeSamples: Int
 
+    /// Hardware output sample rate — read at connect time from the engine's output node.
+    /// The player node connects at this rate so AVAudioEngine injects no hidden resampler,
+    /// keeping the AEC echo reference deterministically timed.
+    private var hardwareSampleRate: Double = 48000
+
+    /// Number of frames written to the hardware-rate PCM buffer per scheduled buffer.
+    /// Always >= frameSizeSamples; computed as hardwareSampleRate / 50 (20 ms chunks).
+    private var hwFramesPerBuffer: Int = 960
+
     // ── Threading / state ───────────────────────────────────────────────
     private var running = false
     private let turnLock = NSLock()
@@ -85,6 +95,15 @@ class AudioPipeline: SharedAudioEngineDelegate {
     /// This prevents duplicate chains and stale callbacks from re-entering after a rebuild.
     private var scheduleGeneration: Int = 0
 
+    /// All `node.scheduleBuffer(...)` calls for this pipeline run on the shared
+    /// engine's serial `engineQueue` (the same queue that owns stop/detach/attach),
+    /// so `scheduleBuffer()` and teardown's `stop()` can never overlap — that
+    /// overlap is the AVAudioPlayerNode deadlock (AttachAndEngineLock ⇄
+    /// RealtimeMessenger). The buffer-completion callback re-arms via
+    /// `engineQueue.async` (returns immediately so `stop()`'s message flush isn't
+    /// blocked); teardown runs on the same queue via `sharedEngine.performSync`,
+    /// so it's serialized after any in-flight scheduling with no explicit barrier.
+
     /// Pending PlaybackStopped dispatch — cancelled on new turn / disconnect.
     /// Always mutate from the main queue to avoid races with the drain timer.
     private var pendingPlaybackStoppedWork: DispatchWorkItem?
@@ -134,12 +153,26 @@ class AudioPipeline: SharedAudioEngineDelegate {
         }
         setState(.connecting)
 
+        guard let sharedEngine = sharedEngine else {
+            setState(.error)
+            throw NSError(domain: "AudioPipeline", code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "SharedAudioEngine not set"])
+        }
+
         do {
-            guard let sharedEngine = sharedEngine else {
-                throw NSError(domain: "AudioPipeline", code: -1,
-                    userInfo: [NSLocalizedDescriptionKey: "SharedAudioEngine not set"])
-            }
+            // All graph setup runs on the engine's serial queue so attach / play /
+            // seed are serialized against route-change, scheduleBuffer and teardown.
+            try sharedEngine.performSync { try self.connectOnQueue(sharedEngine: sharedEngine) }
+        } catch {
+            Logger.debug("[\(AudioPipeline.TAG)] connect() failed: \(error)")
+            setState(.error)
+            disconnect()
+            throw error
+        }
+    }
 
+    /// Graph setup for `connect()`. Runs entirely on `sharedEngine.engineQueue`.
+    private func connectOnQueue(sharedEngine: SharedAudioEngine) throws {
             // ── 1. JitterBuffer ─────────────────────────────────────────
             jitterBuffer = JitterBuffer(
                 sampleRate: sampleRate,
@@ -155,10 +188,21 @@ class AudioPipeline: SharedAudioEngineDelegate {
             // (ensureAudioSessionInitialized). Just ensure it's active.
             try AVAudioSession.sharedInstance().setActive(true)
 
-            // ── 4. Create format and attach player node to shared engine ─
+            // ── 4. Read hardware rate and create hardware-rate format ───
+            // Connecting at the native hardware rate prevents AVAudioEngine from
+            // injecting a hidden resampler between the player node and the hardware
+            // output. A hidden resampler shifts buffer timestamps and desynchronises
+            // the AEC echo reference, causing the adaptive filter to converge slowly
+            // or not at all. The scheduling loop handles the 16kHz→48kHz conversion
+            // via linear interpolation before handing buffers to the player node.
+            let rawHwRate = sharedEngine.engine?.outputNode.outputFormat(forBus: 0).sampleRate ?? 0
+            let resolvedHwRate = rawHwRate > 0 ? rawHwRate : 48000
+            hardwareSampleRate = resolvedHwRate
+            hwFramesPerBuffer = max(1, Int(resolvedHwRate / 50.0))
+
             guard let format = AVAudioFormat(
                 commonFormat: .pcmFormatFloat32,
-                sampleRate: Double(sampleRate),
+                sampleRate: resolvedHwRate,
                 channels: AVAudioChannelCount(channelCount),
                 interleaved: false
             ) else {
@@ -196,20 +240,30 @@ class AudioPipeline: SharedAudioEngineDelegate {
             startFrequencyBandTimer()
 
             setState(.idle)
-            Logger.debug("[\(AudioPipeline.TAG)] Connected — sampleRate=\(sampleRate) " +
-                "ch=\(channelCount) frameSamples=\(frameSizeSamples) " +
+            Logger.debug("[\(AudioPipeline.TAG)] Connected — pipelineRate=\(sampleRate) " +
+                "hwRate=\(Int(resolvedHwRate)) ch=\(channelCount) " +
+                "pipelineFrames=\(frameSizeSamples) hwFrames=\(hwFramesPerBuffer) " +
                 "targetBuffer=\(targetBufferMs)ms")
-        } catch {
-            Logger.debug("[\(AudioPipeline.TAG)] connect() failed: \(error)")
-            setState(.error)
-            disconnect()
-            throw error
-        }
     }
 
     func disconnect() {
+        // Run teardown on the engine's serial queue so it's serialized after any
+        // in-flight scheduleBuffer pass and against route-change/interruption —
+        // no explicit barrier needed. If the shared engine is already gone
+        // (module destroyed), just clean up local state.
+        if let sharedEngine = sharedEngine {
+            sharedEngine.performSync { self.disconnectOnQueue() }
+        } else {
+            disconnectOnQueue()
+        }
+    }
+
+    /// Teardown body. Runs on `sharedEngine.engineQueue` (via `performSync`), so
+    /// `running = false` and `detachNode`'s `stop()` are ordered after any
+    /// scheduling pass; a buffer completion that fires during `stop()` only
+    /// re-enqueues onto the same queue and then bails on `running == false`.
+    private func disconnectOnQueue() {
         // Cancel any pending PlaybackStopped before tearing down.
-        // DispatchWorkItem.cancel is thread-safe; we may be on any queue here.
         pendingPlaybackStoppedWork?.cancel()
         pendingPlaybackStoppedWork = nil
 
@@ -227,7 +281,8 @@ class AudioPipeline: SharedAudioEngineDelegate {
         frequencyBandAnalyzer = nil
         lastEmittedBands = nil
 
-        // Detach node from shared engine (handles pause/stop/disconnect/detach)
+        // Detach node from shared engine (handles pause/stop/disconnect/detach).
+        // detachNode is performSync → runs inline since we're already on the queue.
         if let node = playerNode {
             sharedEngine?.detachNode(node)
         }
@@ -278,14 +333,27 @@ class AudioPipeline: SharedAudioEngineDelegate {
         // Old node is invalid (detached during teardown). Create a fresh one.
         scheduleGeneration += 1
 
-        guard let sharedEngine = sharedEngine,
-              let format = AVAudioFormat(
-                  commonFormat: .pcmFormatFloat32,
-                  sampleRate: Double(sampleRate),
-                  channels: AVAudioChannelCount(channelCount),
-                  interleaved: false
-              ) else {
-            Logger.debug("[\(AudioPipeline.TAG)] engineDidRebuild — cannot create format or engine missing, treating as dead")
+        guard let sharedEngine = sharedEngine else {
+            Logger.debug("[\(AudioPipeline.TAG)] engineDidRebuild — engine missing, treating as dead")
+            running = false
+            setState(.error)
+            listener?.onError(code: "ENGINE_DIED", message: "Failed to recreate audio node after engine rebuild")
+            return
+        }
+
+        // Re-read hardware rate from the new engine (route may have changed).
+        let rawHwRate = sharedEngine.engine?.outputNode.outputFormat(forBus: 0).sampleRate ?? 0
+        let resolvedHwRate = rawHwRate > 0 ? rawHwRate : hardwareSampleRate
+        hardwareSampleRate = resolvedHwRate
+        hwFramesPerBuffer = max(1, Int(resolvedHwRate / 50.0))
+
+        guard let format = AVAudioFormat(
+            commonFormat: .pcmFormatFloat32,
+            sampleRate: resolvedHwRate,
+            channels: AVAudioChannelCount(channelCount),
+            interleaved: false
+        ) else {
+            Logger.debug("[\(AudioPipeline.TAG)] engineDidRebuild — cannot create format, treating as dead")
             running = false
             setState(.error)
             listener?.onError(code: "ENGINE_DIED", message: "Failed to recreate audio node after engine rebuild")
@@ -344,6 +412,11 @@ class AudioPipeline: SharedAudioEngineDelegate {
     func audioSessionInterruptionEnded() {
         Logger.debug("[\(AudioPipeline.TAG)] Audio session interruption ended")
         isInterrupted = false
+        // Reset the zombie baseline as we clear the interruption: scheduling was
+        // stalled while interrupted, and the re-seed below runs asynchronously on
+        // the engine queue, so without this the zombie timer could false-positive
+        // in the gap before the first resumed buffer is scheduled.
+        lastScheduleTime = Date()
         // Engine already restarted by SharedAudioEngine. Re-seed scheduling.
         if running {
             scheduleGeneration += 1
@@ -465,7 +538,19 @@ class AudioPipeline: SharedAudioEngineDelegate {
     // Scheduling loop
     // ════════════════════════════════════════════════════════════════════
 
+    /// Request one buffer-scheduling pass. Hops onto the shared engine's serial
+    /// `engineQueue` so the actual `scheduleBuffer()` is serialized against
+    /// teardown's `stop()` and graph mutations. All re-seed call sites (connect,
+    /// route change, rebuild, interruption) use this; the completion handler
+    /// re-arms via `engineQueue.async` directly (see below).
     private func scheduleNextBuffer() {
+        sharedEngine?.engineQueue.async { [weak self] in
+            self?.scheduleNextBufferOnQueue()
+        }
+    }
+
+    /// Build and schedule the next PCM buffer. MUST run on `engineQueue`.
+    private func scheduleNextBufferOnQueue() {
         guard running,
               let se = sharedEngine, !se.isRebuilding,
               let buf = jitterBuffer,
@@ -490,28 +575,35 @@ class AudioPipeline: SharedAudioEngineDelegate {
             }
         }
 
-        // Convert to non-interleaved Float32 for AVAudioEngine
-        let framesPerBuffer = frameSizeSamples / channelCount
+        // Build a hardware-rate PCM buffer. The scheduling loop resamples from
+        // pipeline rate (e.g. 16 kHz) to hardware rate (e.g. 48 kHz) so the
+        // player node connects at the native rate and the engine never inserts a
+        // hidden resampler that would desynchronise the AEC echo reference.
+        let pipelineFrames = frameSizeSamples / channelCount  // frames at pipeline rate
+        let hwFrames       = hwFramesPerBuffer                 // frames at hardware rate
         guard let pcmBuffer = AVAudioPCMBuffer(
             pcmFormat: format,
-            frameCapacity: AVAudioFrameCount(framesPerBuffer)
+            frameCapacity: AVAudioFrameCount(hwFrames)
         ) else { return }
-        pcmBuffer.frameLength = AVAudioFrameCount(framesPerBuffer)
+        pcmBuffer.frameLength = AVAudioFrameCount(hwFrames)
 
         if let channelData = pcmBuffer.floatChannelData {
             if isInterrupted {
-                // Write silence during interruption
                 for ch in 0..<channelCount {
-                    for i in 0..<framesPerBuffer {
-                        channelData[ch][i] = 0
-                    }
+                    for i in 0..<hwFrames { channelData[ch][i] = 0 }
                 }
             } else {
-                // De-interleave Int16 → non-interleaved Float32
-                for frame in 0..<framesPerBuffer {
+                // Linear interpolation: pipeline rate → hardware rate
+                let ratio = hardwareSampleRate / Double(sampleRate)
+                for i in 0..<hwFrames {
+                    let virtualIndex = Double(i) / ratio
+                    let indexLow  = Int(virtualIndex)
+                    let indexHigh = min(indexLow + 1, pipelineFrames - 1)
+                    let weight    = Float(virtualIndex - Double(indexLow))
                     for ch in 0..<channelCount {
-                        let sampleIndex = frame * channelCount + ch
-                        channelData[ch][frame] = Float(renderSamples[sampleIndex]) / 32768.0
+                        let sampleLow  = Float(renderSamples[indexLow  * channelCount + ch]) / 32768.0
+                        let sampleHigh = Float(renderSamples[indexHigh * channelCount + ch]) / 32768.0
+                        channelData[ch][i] = sampleLow + weight * (sampleHigh - sampleLow)
                     }
                 }
             }
@@ -521,11 +613,21 @@ class AudioPipeline: SharedAudioEngineDelegate {
         lastScheduleTime = Date()
 
         node.scheduleBuffer(pcmBuffer) { [weak self] in
-            guard let self = self, self.running else { return }
-            // Bail if this completion belongs to a previous scheduling generation
-            // (route change rebuilt the engine while this buffer was in flight).
-            guard self.scheduleGeneration == capturedGeneration else { return }
-            self.scheduleNextBuffer()
+            guard let self = self else { return }
+            // Re-arm on the engine queue. Returning from this completion callback
+            // IMMEDIATELY is essential: AVAudioPlayerNode.stop() flushes pending
+            // completion messages synchronously while holding the engine lock, so
+            // calling scheduleBuffer() inline here would deadlock a concurrent
+            // stop() (AttachAndEngineLock ⇄ RealtimeMessenger mutex). Hopping to
+            // engineQueue lets stop() drain us without blocking, and serializes
+            // the next scheduleBuffer() against teardown on the same queue.
+            self.sharedEngine?.engineQueue.async {
+                // Bail if torn down, or if this completion belongs to a previous
+                // scheduling generation (route change rebuilt the engine while
+                // this buffer was in flight).
+                guard self.running, self.scheduleGeneration == capturedGeneration else { return }
+                self.scheduleNextBufferOnQueue()
+            }
         }
     }
 
@@ -631,7 +733,11 @@ class AudioPipeline: SharedAudioEngineDelegate {
         timer.setEventHandler { [weak self] in
             guard let self = self else { return }
             let stalledMs = Int64(Date().timeIntervalSince(self.lastScheduleTime) * 1000)
+            // Don't flag a zombie while interrupted: the engine is stopped, so
+            // scheduling legitimately stalls (no buffers feed) until resume. The
+            // stall is expected, not a dead scheduling loop.
             if stalledMs >= AudioPipeline.ZOMBIE_STALL_THRESHOLD_MS &&
+               !self.isInterrupted &&
                (self.state == .streaming || self.state == .draining) {
                 Logger.debug("[\(AudioPipeline.TAG)] Zombie detected! stalledMs=\(stalledMs)")
                 self.listener?.onZombieDetected(stalledMs: stalledMs)

package/ios/ExpoPlayAudioStreamModule.swift

@@ -165,6 +165,10 @@ public class ExpoPlayAudioStreamModule: Module, MicrophoneDataDelegate, Pipeline
             microphone.toggleSilence(isSilent: isSilent)
         }
 
+        Function("setMicrophoneGain") { (gain: Double) in
+            microphone.setMicrophoneGain(Float(gain))
+        }
+
         // ── Pipeline functions ────────────────────────────────────────────
 
         AsyncFunction("connectPipeline") { (options: [String: Any], promise: Promise) in

package/ios/Microphone.swift

@@ -9,6 +9,14 @@ class Microphone: SharedAudioEngineDelegate {
     /// Must be set and configured before calling startRecording.
     weak var sharedAudioEngine: SharedAudioEngine?
 
+    /// Serial queue for mic-input processing. The tap fires on AVFoundation's
+    /// real-time render thread; we copy the buffer and hop here so resampling,
+    /// frequency analysis and the JS `sendEvent` never run on that thread (a
+    /// real-time violation that can stall capture or invert priority). Kept
+    /// separate from the engine queue so a congested JS bridge on the mic path
+    /// can't stall playback scheduling.
+    private let micQueue = DispatchQueue(label: "expo.modules.audio.microphone")
+
     public private(set) var isVoiceProcessingEnabled: Bool = false
 
     internal var lastEmittedSize: Int64 = 0
@@ -22,6 +30,9 @@ class Microphone: SharedAudioEngineDelegate {
 
     private var isRecording: Bool = false
     private var isSilent: Bool = false
+    // Read on the audio render thread, written from the JS thread.
+    // Float is 4 bytes / naturally aligned — atomic on ARM64, no lock needed.
+    private var micGain: Float = 1.0
     private var frequencyBandAnalyzer: FrequencyBandAnalyzer?
     private var frequencyBandConfig: (lowCrossoverHz: Float, highCrossoverHz: Float)?
 
@@ -116,6 +127,10 @@ class Microphone: SharedAudioEngineDelegate {
         self.isSilent = isSilent
     }
 
+    func setMicrophoneGain(_ gain: Float) {
+        micGain = max(0.0, min(1.0, gain))
+    }
+
     func startRecording(settings: RecordingSettings, intervalMilliseconds: Int,
                         frequencyBandConfig: (lowCrossoverHz: Float, highCrossoverHz: Float)? = nil) -> StartRecordingResult? {
         guard !isRecording else {
@@ -205,29 +220,63 @@ class Microphone: SharedAudioEngineDelegate {
         let hardwareFormat = inputNode.inputFormat(forBus: 0)
         recordingSettings?.sampleRate = hardwareFormat.sampleRate
 
+        // outputFormat is what the tap actually receives — under VoiceProcessingIO
+        // this may differ from inputFormat (VP may output at a different rate and
+        // adds internal metadata channels beyond channel 0).
+        let nodeOutputFormat = inputNode.outputFormat(forBus: 0)
+
         let intervalSamples = AVAudioFrameCount(
-            Double(intervalMilliseconds) / 1000.0 * hardwareFormat.sampleRate
+            Double(intervalMilliseconds) / 1000.0 * nodeOutputFormat.sampleRate
         )
         let tapBufferSize = max(intervalSamples, 256)
 
-        inputNode.installTap(onBus: 0, bufferSize: tapBufferSize, format: nil) { [weak self] (buffer, time) in
+        // Explicit mono Float32 format strips VP metadata channels. Passing format: nil
+        // here would deliver the raw VP output channels, corrupting the audio stream
+        // with echo-tracking metadata that bleeds into downstream processing.
+        let tapFormat = AVAudioFormat(
+            commonFormat: .pcmFormatFloat32,
+            sampleRate: nodeOutputFormat.sampleRate,
+            channels: 1,
+            interleaved: false
+        )
+
+        inputNode.installTap(onBus: 0, bufferSize: tapBufferSize, format: tapFormat) { [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
-                ))
+                self.micQueue.async {
+                    self.delegate?.onMicrophoneError(MicrophoneErrorInfo(
+                        code: "READ_ERROR",
+                        message: "Received empty audio buffer",
+                        isFatal: false,
+                        autoResuming: false
+                    ))
+                }
                 return
             }
-            self.processAudioBuffer(buffer)
-            self.lastBufferTime = time
+            // Convert on the render thread — the tap buffer is only valid here, and
+            // the conversion yields the `Data` we'd build anyway, so there's no
+            // extra copy. Hand the value-typed result to the serial queue; only the
+            // JS-bridge delivery (sendEvent) runs off the render thread. Nothing
+            // here re-enters the engine, so no separate queue is needed for safety —
+            // micQueue exists purely to keep the bridge call off the render thread
+            // and preserve chunk ordering.
+            guard let payload = self.extractMicData(from: buffer) else { return }
+            self.micQueue.async {
+                self.totalDataSize += Int64(payload.data.count)
+                self.delegate?.onMicrophoneData(payload.data, payload.powerLevel, payload.bands)
+                self.lastEmittedSize = self.totalDataSize
+                self.lastBufferTime = time
+            }
         }
     }
 
-    private func processAudioBuffer(_ buffer: AVAudioPCMBuffer) {
+    /// Convert a tap buffer into the value-typed payload the delegate needs
+    /// (PCM `Data`, power level, frequency bands). Runs on the audio render
+    /// thread — it needs the live buffer — but does no cross-thread work, so the
+    /// caller hands the result to `micQueue` for the JS-bridge delivery. Returns
+    /// nil if the buffer yields no data.
+    private func extractMicData(from buffer: AVAudioPCMBuffer) -> (data: Data, powerLevel: Float, bands: FrequencyBands?)? {
         let targetSampleRate = recordingSettings?.desiredSampleRate ?? buffer.format.sampleRate
         let targetBitDepth = recordingSettings?.bitDepth ?? 16
         var currentBuffer = buffer
@@ -261,7 +310,7 @@ class Microphone: SharedAudioEngineDelegate {
             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]))
+                    let sample = max(-1.0, min(1.0, floatData[ch][frame] * micGain))
                     var int16Sample = Int16(sample * 32767.0)
                     int16Data.append(Data(bytes: &int16Sample, count: 2))
                 }
@@ -271,7 +320,7 @@ class Microphone: SharedAudioEngineDelegate {
             let audioData = currentBuffer.audioBufferList.pointee.mBuffers
             guard let bufferData = audioData.mData else {
                 Logger.debug("[Microphone] Buffer data is nil.")
-                return
+                return nil
             }
             data = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
         }
@@ -286,8 +335,6 @@ class Microphone: SharedAudioEngineDelegate {
             bands = nil
         }
 
-        totalDataSize += Int64(data.count)
-        self.delegate?.onMicrophoneData(data, powerLevel, bands)
-        self.lastEmittedSize = totalDataSize
+        return (data, powerLevel, bands)
     }
 }

package/ios/SharedAudioEngine.swift

@@ -49,7 +49,33 @@ extension SharedAudioEngineDelegate {
 class SharedAudioEngine {
     private static let TAG = "SharedAudioEngine"
 
-    private let lock = NSRecursiveLock()
+    /// The single serial queue that owns ALL engine graph work: every
+    /// attach/detach/connect/stop/start/configure/teardown, the playback
+    /// `scheduleBuffer` loop (driven from AudioPipeline), and route/interruption
+    /// handling. Serial ordering here is what makes the AVAudioPlayerNode
+    /// `stop()`/`scheduleBuffer()` deadlock structurally impossible — they can't
+    /// overlap on one serial queue. AVFoundation callbacks hop on via `async`
+    /// (never `sync` — they may run with an AV lock held); Expo functions enter
+    /// via `performSync`. Replaces the former recursive lock.
+    let engineQueue = DispatchQueue(label: "expo.modules.audio.engine")
+    private static let queueKey = DispatchSpecificKey<Void>()
+
+    init() {
+        engineQueue.setSpecific(key: SharedAudioEngine.queueKey, value: ())
+    }
+
+    /// Run `work` synchronously in the engine's serial domain. Re-entrancy-aware:
+    /// if we're already on `engineQueue` (a delegate callback fired from
+    /// `notifyDelegates`, or `configure` calling `teardown`/`attachNode`) we run
+    /// inline instead of dead-locking on `engineQueue.sync`. This is exactly what
+    /// the *recursive* lock used to provide. Callers on AVFoundation callback
+    /// threads must use `engineQueue.async` instead — never this.
+    func performSync<T>(_ work: () throws -> T) rethrows -> T {
+        if DispatchQueue.getSpecific(key: SharedAudioEngine.queueKey) != nil {
+            return try work()
+        }
+        return try engineQueue.sync(execute: work)
+    }
 
     // ── Engine state ─────────────────────────────────────────────────────
     private(set) var engine: AVAudioEngine?
@@ -61,17 +87,17 @@ class SharedAudioEngine {
     private let delegates = NSHashTable<AnyObject>.weakObjects()
 
     func addDelegate(_ d: SharedAudioEngineDelegate) {
-        lock.lock()
-        defer { lock.unlock() }
-        if !delegates.contains(d as AnyObject) {
-            delegates.add(d as AnyObject)
+        performSync {
+            if !delegates.contains(d as AnyObject) {
+                delegates.add(d as AnyObject)
+            }
         }
     }
 
     func removeDelegate(_ d: SharedAudioEngineDelegate) {
-        lock.lock()
-        defer { lock.unlock() }
-        delegates.remove(d as AnyObject)
+        performSync {
+            delegates.remove(d as AnyObject)
+        }
     }
 
     private func notifyDelegates(_ block: (SharedAudioEngineDelegate) -> Void) {
@@ -100,12 +126,19 @@ class SharedAudioEngine {
     ///
     /// - Parameter playbackMode: Determines whether voice processing is enabled.
     func configure(playbackMode: PlaybackMode) throws {
-        lock.lock()
-        defer { lock.unlock() }
-        if isConfigured && self.playbackMode == playbackMode && engine?.isRunning == true {
+        try performSync { try configureOnQueue(playbackMode: playbackMode) }
+    }
+
+    private func configureOnQueue(playbackMode: PlaybackMode) throws {
+        let needsVP = playbackMode == .conversation || playbackMode == .voiceProcessing
+        let vpActive = !needsVP || (engine?.inputNode.isVoiceProcessingEnabled == true)
+        if isConfigured && self.playbackMode == playbackMode && engine?.isRunning == true && vpActive {
             Logger.debug("[\(SharedAudioEngine.TAG)] Already configured for \(playbackMode) and engine running, skipping")
             return
         }
+        if isConfigured && !vpActive {
+            Logger.debug("[\(SharedAudioEngine.TAG)] Voice processing dropped (setCategory side-effect) — forcing reconfiguration")
+        }
 
         if isConfigured && engine?.isRunning != true {
             Logger.debug("[\(SharedAudioEngine.TAG)] Engine marked configured but not running — forcing reconfiguration")
@@ -123,7 +156,6 @@ class SharedAudioEngine {
         // Done before connecting nodes so the audio graph incorporates VP from the start.
         if playbackMode == .conversation || playbackMode == .voiceProcessing {
             try engine.inputNode.setVoiceProcessingEnabled(true)
-            try engine.outputNode.setVoiceProcessingEnabled(true)
             Logger.debug("[\(SharedAudioEngine.TAG)] Voice processing enabled")
         }
 
@@ -168,8 +200,10 @@ class SharedAudioEngine {
     /// Connects `node → mainMixerNode` with the given format.
     /// The mixer handles sample-rate conversion to hardware output.
     func attachNode(_ node: AVAudioPlayerNode, format: AVAudioFormat) {
-        lock.lock()
-        defer { lock.unlock() }
+        performSync { attachNodeOnQueue(node, format: format) }
+    }
+
+    private func attachNodeOnQueue(_ node: AVAudioPlayerNode, format: AVAudioFormat) {
         guard let engine = engine else {
             Logger.debug("[\(SharedAudioEngine.TAG)] attachNode called but engine is nil")
             return
@@ -184,8 +218,10 @@ class SharedAudioEngine {
 
     /// Detach a consumer's player node from the shared engine.
     func detachNode(_ node: AVAudioPlayerNode) {
-        lock.lock()
-        defer { lock.unlock() }
+        performSync { detachNodeOnQueue(node) }
+    }
+
+    private func detachNodeOnQueue(_ node: AVAudioPlayerNode) {
         guard let engine = engine else { return }
 
         node.pause()
@@ -209,8 +245,10 @@ class SharedAudioEngine {
 
     /// Tear down the engine completely. Called on reconfigure or module destroy.
     func teardown() {
-        lock.lock()
-        defer { lock.unlock() }
+        performSync { teardownOnQueue() }
+    }
+
+    private func teardownOnQueue() {
         // Remove observers
         NotificationCenter.default.removeObserver(
             self, name: AVAudioSession.routeChangeNotification, object: nil)
@@ -236,7 +274,6 @@ class SharedAudioEngine {
         if playbackMode == .conversation || playbackMode == .voiceProcessing {
             if let engine = engine {
                 try? engine.inputNode.setVoiceProcessingEnabled(false)
-                try? engine.outputNode.setVoiceProcessingEnabled(false)
             }
         }
 
@@ -260,10 +297,15 @@ class SharedAudioEngine {
               let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue) else {
             return
         }
+        // Hop off AVFoundation's notification thread onto the engine queue before
+        // touching the engine or session — that thread can hold an internal lock
+        // when delivering this, and the queue serializes us against connect/disconnect.
+        engineQueue.async { [weak self] in
+            self?.handleRouteChangeOnQueue(reason: reason)
+        }
+    }
 
-        lock.lock()
-        defer { lock.unlock() }
-
+    private func handleRouteChangeOnQueue(reason: AVAudioSession.RouteChangeReason) {
         let routeDescription = AVAudioSession.sharedInstance().currentRoute.outputs
             .map { "\($0.portName) (\($0.portType.rawValue))" }
             .joined(separator: ", ")
@@ -311,7 +353,6 @@ class SharedAudioEngine {
             if playbackMode == .conversation || playbackMode == .voiceProcessing {
                 do {
                     try engine.inputNode.setVoiceProcessingEnabled(true)
-                    try engine.outputNode.setVoiceProcessingEnabled(true)
                 } catch {
                     Logger.debug("[\(SharedAudioEngine.TAG)] Voice processing re-enable failed: \(error)")
                 }
@@ -410,7 +451,7 @@ class SharedAudioEngine {
             // Voice processing can cause the engine to die asynchronously after
             // appearing to start. Wait 100ms then re-verify before declaring success.
             let verifyDelay: TimeInterval = (self.playbackMode == .conversation || self.playbackMode == .voiceProcessing) ? 0.1 : 0.05
-            DispatchQueue.main.asyncAfter(deadline: .now() + verifyDelay) { [weak self] in
+            self.engineQueue.asyncAfter(deadline: .now() + verifyDelay) { [weak self] in
                 guard let self = self, let engine = self.engine else {
                     self?.isRebuildingForRouteChange = false
                     return
@@ -449,7 +490,7 @@ class SharedAudioEngine {
 
         if delay > 0 {
             Logger.debug("[\(SharedAudioEngine.TAG)] Waiting \(Int(delay * 1000))ms before attempt \(attempt + 1)")
-            DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: work)
+            engineQueue.asyncAfter(deadline: .now() + delay, execute: work)
         } else {
             work()
         }
@@ -493,16 +534,19 @@ class SharedAudioEngine {
         guard let info = notification.userInfo,
               let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt,
               let type = AVAudioSession.InterruptionType(rawValue: typeValue) else { return }
+        let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt ?? 0
+        // Hop off AVFoundation's notification thread onto the engine queue.
+        engineQueue.async { [weak self] in
+            self?.handleInterruptionOnQueue(type: type, optionsValue: optionsValue)
+        }
+    }
 
-        lock.lock()
-        defer { lock.unlock() }
-
+    private func handleInterruptionOnQueue(type: AVAudioSession.InterruptionType, optionsValue: UInt) {
         if type == .began {
             Logger.debug("[\(SharedAudioEngine.TAG)] Audio session interruption began")
             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.
@@ -529,6 +573,8 @@ class SharedAudioEngine {
     }
 
     deinit {
-        teardown()
+        // At dealloc there are no other references, so no concurrency — run the
+        // body directly rather than dispatching onto the queue during teardown.
+        teardownOnQueue()
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edkimmel/expo-audio-stream",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Expo Play Audio Stream module",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/src/index.ts

@@ -184,6 +184,14 @@ export class ExpoPlayAudioStream {
     ExpoPlayAudioStreamModule.toggleSilence(isSilent);
   }
 
+  /**
+   * Sets the microphone capture gain (0.0 = silent, 1.0 = full).
+   * Takes effect immediately on the next captured audio chunk.
+   */
+  static setMicrophoneGain(gain: number) {
+    ExpoPlayAudioStreamModule.setMicrophoneGain(Math.max(0, Math.min(1, gain)));
+  }
+
   /**
    * Requests microphone permission from the user.
    * @returns {Promise<{granted: boolean, canAskAgain?: boolean, status?: string}>} A promise that resolves to the permission result.