@edkimmel/expo-audio-stream 0.2.0

package/android/src/main/java/expo/modules/audiostream/pipeline/JitterBuffer.kt

@@ -0,0 +1,227 @@
+package expo.modules.audiostream.pipeline
+
+import java.util.ArrayDeque
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+/**
+ * Lock-based chunk queue for PCM audio (16-bit signed, little-endian).
+ *
+ * Single producer (bridge thread) writes decoded PCM via [write].
+ * Single consumer (write thread) drains via [read].
+ * All shared state is guarded by a [ReentrantLock].
+ *
+ * Features:
+ *   - Chunk queue: incoming [ShortArray] chunks are enqueued by reference
+ *     (zero-copy on the producer side). No fixed capacity limit.
+ *   - Priming gate: [read] returns silence until [targetBufferMs] of audio has
+ *     accumulated (or [markEndOfStream] force-primes so the tail drains).
+ *   - Silence-fill on underflow: when the buffer has fewer samples than the
+ *     consumer requested, the remainder is filled with silence and an underrun
+ *     is counted.
+ *   - Telemetry via atomics: total frames written/read, underrun count, peak
+ *     buffer level – all readable without acquiring the lock.
+ */
+class JitterBuffer(
+    /** Sample rate in Hz — used to convert between samples and milliseconds. */
+    private val sampleRate: Int,
+    /** Number of channels (1 = mono, 2 = stereo). */
+    private val channels: Int,
+    /** How many ms of audio to accumulate before the priming gate opens. */
+    private val targetBufferMs: Int
+) {
+    // ── Chunk queue storage ──────────────────────────────────────────────
+    private val chunks = ArrayDeque<ShortArray>()
+    private var readCursor = 0        // offset into the head chunk
+    private var count = 0             // total live samples across all chunks
+
+    // ── Priming gate ────────────────────────────────────────────────────
+    private val primingSamples: Int =
+        (sampleRate * channels * targetBufferMs) / 1000
+    private var primed = false
+
+    // ── End-of-stream ───────────────────────────────────────────────────
+    private var endOfStream = false
+
+    // ── Lock ────────────────────────────────────────────────────────────
+    private val lock = ReentrantLock()
+
+    // ── Telemetry (lock-free reads) ─────────────────────────────────────
+    /** Total samples written by the producer since last [reset]. */
+    val totalWritten = AtomicLong(0)
+
+    /** Total samples read by the consumer since last [reset]. */
+    val totalRead = AtomicLong(0)
+
+    /** Number of underrun events (consumer asked for more than available). */
+    val underrunCount = AtomicInteger(0)
+
+    /** Peak buffer level in samples observed at write time. */
+    val peakLevel = AtomicInteger(0)
+
+    // ── Producer API ────────────────────────────────────────────────────
+
+    /**
+     * Enqueue [samples] into the chunk queue.
+     *
+     * When the full array is passed (offset == 0, length == samples.size),
+     * the array reference is stored directly — zero copy. Otherwise a
+     * subrange copy is made.
+     *
+     * @return number of samples enqueued (always [length]).
+     */
+    fun write(samples: ShortArray, offset: Int = 0, length: Int = samples.size): Int {
+        lock.withLock {
+            val chunk = if (offset == 0 && length == samples.size) {
+                samples
+            } else {
+                samples.copyOfRange(offset, offset + length)
+            }
+
+            chunks.addLast(chunk)
+            count += length
+
+            // Update peak telemetry
+            if (count > peakLevel.get()) {
+                peakLevel.set(count)
+            }
+
+            totalWritten.addAndGet(length.toLong())
+
+            // Check priming
+            if (!primed && count >= primingSamples) {
+                primed = true
+            }
+
+            return length
+        }
+    }
+
+    // ── Consumer API ────────────────────────────────────────────────────
+
+    /**
+     * Fill [dest] with up to [length] samples from the chunk queue.
+     *
+     * Behaviour depends on the priming gate:
+     *   - **Not primed & no end-of-stream**: fills [dest] with silence and
+     *     returns [length] (the consumer keeps writing silence to AudioTrack
+     *     so it stays alive).
+     *   - **Primed (or EOS forced-prime)**: copies available samples; if fewer
+     *     than [length] are available the remainder is zero-filled and an
+     *     underrun is recorded.
+     *
+     * @return the number of samples placed in [dest] (always [length]).
+     */
+    fun read(dest: ShortArray, offset: Int = 0, length: Int = dest.size): Int {
+        lock.withLock {
+            if (!primed) {
+                // Still priming – fill with silence
+                dest.fill(0, offset, offset + length)
+                return length
+            }
+
+            var destPos = offset
+            var remaining = length
+
+            while (remaining > 0 && chunks.isNotEmpty()) {
+                val chunk = chunks.peekFirst()
+                val available = chunk.size - readCursor
+                val toCopy = minOf(available, remaining)
+
+                System.arraycopy(chunk, readCursor, dest, destPos, toCopy)
+                readCursor += toCopy
+                destPos += toCopy
+                remaining -= toCopy
+                count -= toCopy
+
+                if (readCursor >= chunk.size) {
+                    chunks.pollFirst()
+                    readCursor = 0
+                }
+            }
+
+            // Silence-fill remainder on underflow
+            if (remaining > 0) {
+                dest.fill(0, destPos, destPos + remaining)
+                // Only count as underrun if we expected more data (not drained)
+                if (!endOfStream) {
+                    underrunCount.incrementAndGet()
+                }
+            }
+
+            totalRead.addAndGet(length.toLong())
+            return length
+        }
+    }
+
+    // ── Control API ─────────────────────────────────────────────────────
+
+    /**
+     * Mark that the producer will not write any more data for this turn.
+     * Force-primes the buffer so the consumer can drain whatever remains
+     * rather than waiting for [targetBufferMs] to fill.
+     */
+    fun markEndOfStream() {
+        lock.withLock {
+            endOfStream = true
+            if (!primed) {
+                primed = true  // force open the gate so tail audio drains
+            }
+        }
+    }
+
+    /** @return `true` after [markEndOfStream] was called AND the buffer is empty. */
+    fun isDrained(): Boolean {
+        lock.withLock {
+            return endOfStream && count == 0
+        }
+    }
+
+    /** Current buffer level in samples (snapshot). */
+    fun availableSamples(): Int {
+        lock.withLock {
+            return count
+        }
+    }
+
+    /** Current buffer level converted to milliseconds. */
+    fun bufferedMs(): Int {
+        lock.withLock {
+            return if (sampleRate * channels == 0) 0
+            else (count * 1000) / (sampleRate * channels)
+        }
+    }
+
+    /** Whether the priming gate is currently open. */
+    fun isPrimed(): Boolean {
+        lock.withLock {
+            return primed
+        }
+    }
+
+    /**
+     * Reset the buffer to its initial empty state.
+     * Called on turn changes to discard stale audio.
+     */
+    fun reset() {
+        lock.withLock {
+            chunks.clear()
+            readCursor = 0
+            count = 0
+            primed = false
+            endOfStream = false
+        }
+        // Telemetry is deliberately NOT reset here — the pipeline resets
+        // telemetry at reconnect via [resetTelemetry].
+    }
+
+    /** Reset all telemetry counters to zero. */
+    fun resetTelemetry() {
+        totalWritten.set(0)
+        totalRead.set(0)
+        underrunCount.set(0)
+        peakLevel.set(0)
+    }
+}

package/android/src/main/java/expo/modules/audiostream/pipeline/PipelineIntegration.kt

@@ -0,0 +1,315 @@
+package expo.modules.audiostream.pipeline
+
+import android.content.Context
+import android.os.Bundle
+import android.util.Log
+import expo.modules.audiostream.EventSender
+
+/**
+ * Bridge layer wiring [AudioPipeline] into the existing ExpoPlayAudioStreamModule.
+ *
+ * This class 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 should declare.
+ *
+ * ┌─────────────────────────────────────────────────────────────────────────┐
+ * │  INTEGRATION STEPS for ExpoPlayAudioStreamModule.kt                    │
+ * │                                                                        │
+ * │  1. Add field:                                                         │
+ * │       private lateinit var pipelineIntegration: PipelineIntegration    │
+ * │                                                                        │
+ * │  2. Initialize after existing managers (inside definition() block):    │
+ * │       initializePipeline()                                             │
+ * │     And add the method:                                                │
+ * │       private fun initializePipeline() {                               │
+ * │           val ctx = appContext.reactContext                             │
+ * │               ?: throw IllegalStateException("Context not available")  │
+ * │           pipelineIntegration = PipelineIntegration(ctx, this)         │
+ * │       }                                                                │
+ * │                                                                        │
+ * │  3. Add 8 event names to the Events() block:                          │
+ * │       PipelineIntegration.EVENT_STATE_CHANGED,                         │
+ * │       PipelineIntegration.EVENT_PLAYBACK_STARTED,                      │
+ * │       PipelineIntegration.EVENT_ERROR,                                 │
+ * │       PipelineIntegration.EVENT_ZOMBIE_DETECTED,                       │
+ * │       PipelineIntegration.EVENT_UNDERRUN,                              │
+ * │       PipelineIntegration.EVENT_DRAINED,                               │
+ * │       PipelineIntegration.EVENT_AUDIO_FOCUS_LOST,                      │
+ * │       PipelineIntegration.EVENT_AUDIO_FOCUS_RESUMED                    │
+ * │                                                                        │
+ * │  4. Add 7 AsyncFunction / Function declarations:                       │
+ * │                                                                        │
+ * │       AsyncFunction("connectPipeline") { options: Map<String, Any?>,   │
+ * │           promise: Promise ->                                          │
+ * │           pipelineIntegration.connect(options, promise)                 │
+ * │       }                                                                │
+ * │                                                                        │
+ * │       AsyncFunction("pushPipelineAudio") { options: Map<String, Any?>, │
+ * │           promise: Promise ->                                          │
+ * │           pipelineIntegration.pushAudio(options, promise)              │
+ * │       }                                                                │
+ * │                                                                        │
+ * │       Function("pushPipelineAudioSync") { options: Map<String, Any?> ->│
+ * │           pipelineIntegration.pushAudioSync(options)                    │
+ * │       }                                                                │
+ * │                                                                        │
+ * │       AsyncFunction("disconnectPipeline") { promise: Promise ->        │
+ * │           pipelineIntegration.disconnect(promise)                       │
+ * │       }                                                                │
+ * │                                                                        │
+ * │       AsyncFunction("invalidatePipelineTurn") {                        │
+ * │           options: Map<String, Any?>, promise: Promise ->              │
+ * │           pipelineIntegration.invalidateTurn(options, promise)          │
+ * │       }                                                                │
+ * │                                                                        │
+ * │       Function("getPipelineTelemetry") {                               │
+ * │           pipelineIntegration.getTelemetry()                            │
+ * │       }                                                                │
+ * │                                                                        │
+ * │       Function("getPipelineState") {                                   │
+ * │           pipelineIntegration.getState()                                │
+ * │       }                                                                │
+ * │                                                                        │
+ * │  5. Call in OnDestroy and destroy():                                   │
+ * │       pipelineIntegration.destroy()                                     │
+ * │                                                                        │
+ * └─────────────────────────────────────────────────────────────────────────┘
+ */
+class PipelineIntegration(
+    private val context: Context,
+    private val eventSender: EventSender
+) : PipelineListener {
+
+    companion object {
+        private const val TAG = "PipelineIntegration"
+
+        // ── Event name constants (match the TS PipelineEventMap keys) ───
+        const val EVENT_STATE_CHANGED      = "PipelineStateChanged"
+        const val EVENT_PLAYBACK_STARTED   = "PipelinePlaybackStarted"
+        const val EVENT_ERROR              = "PipelineError"
+        const val EVENT_ZOMBIE_DETECTED    = "PipelineZombieDetected"
+        const val EVENT_UNDERRUN           = "PipelineUnderrun"
+        const val EVENT_DRAINED            = "PipelineDrained"
+        const val EVENT_AUDIO_FOCUS_LOST   = "PipelineAudioFocusLost"
+        const val EVENT_AUDIO_FOCUS_RESUMED = "PipelineAudioFocusResumed"
+    }
+
+    private var pipeline: AudioPipeline? = null
+
+    // ════════════════════════════════════════════════════════════════════
+    // Bridge methods
+    // ════════════════════════════════════════════════════════════════════
+
+    /**
+     * Connect the pipeline. Creates a new [AudioPipeline] with the given options.
+     *
+     * Options map:
+     *   - `sampleRate` (Int, default 24000)
+     *   - `channelCount` (Int, default 1)
+     *   - `targetBufferMs` (Int, default 80)
+     */
+    fun connect(options: Map<String, Any?>, promise: expo.modules.kotlin.Promise) {
+        try {
+            // Tear down any existing pipeline first
+            pipeline?.disconnect()
+
+            val sampleRate = (options["sampleRate"] as? Number)?.toInt() ?: 24000
+            val channelCount = (options["channelCount"] as? Number)?.toInt() ?: 1
+            val targetBufferMs = (options["targetBufferMs"] as? Number)?.toInt() ?: 80
+
+            pipeline = AudioPipeline(
+                context = context,
+                sampleRate = sampleRate,
+                channelCount = channelCount,
+                targetBufferMs = targetBufferMs,
+                listener = this
+            )
+            pipeline!!.connect()
+
+            val result = Bundle().apply {
+                putInt("sampleRate", sampleRate)
+                putInt("channelCount", channelCount)
+                putInt("targetBufferMs", targetBufferMs)
+                putInt("frameSizeSamples", pipeline!!.frameSizeSamples)
+            }
+            promise.resolve(result)
+        } catch (e: Exception) {
+            Log.e(TAG, "connect failed", e)
+            promise.reject("PIPELINE_CONNECT_ERROR", e.message ?: "Unknown error", e)
+        }
+    }
+
+    /**
+     * Push base64-encoded PCM audio into the jitter buffer (async — resolves Promise).
+     *
+     * Options map:
+     *   - `audio` (String) — base64-encoded PCM16 LE data
+     *   - `turnId` (String) — conversation turn identifier
+     *   - `isFirstChunk` (Boolean, default false)
+     *   - `isLastChunk` (Boolean, default false)
+     */
+    fun pushAudio(options: Map<String, Any?>, promise: expo.modules.kotlin.Promise) {
+        try {
+            val audio = options["audio"] as? String
+                ?: throw IllegalArgumentException("Missing 'audio' field")
+            val turnId = options["turnId"] as? String
+                ?: throw IllegalArgumentException("Missing 'turnId' field")
+            val isFirstChunk = options["isFirstChunk"] as? Boolean ?: false
+            val isLastChunk = options["isLastChunk"] as? Boolean ?: false
+
+            val p = pipeline
+                ?: throw IllegalStateException("Pipeline not connected")
+            p.pushAudio(audio, turnId, isFirstChunk, isLastChunk)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "pushAudio failed", e)
+            promise.reject("PIPELINE_PUSH_ERROR", e.message ?: "Unknown error", e)
+        }
+    }
+
+    /**
+     * Push base64-encoded PCM audio synchronously (Function, not AsyncFunction).
+     * No Promise overhead — designed for the hot path.
+     *
+     * Same options as [pushAudio].
+     */
+    fun pushAudioSync(options: Map<String, Any?>): Boolean {
+        return try {
+            val audio = options["audio"] as? String ?: return false
+            val turnId = options["turnId"] as? String ?: return false
+            val isFirstChunk = options["isFirstChunk"] as? Boolean ?: false
+            val isLastChunk = options["isLastChunk"] as? Boolean ?: false
+
+            pipeline?.pushAudio(audio, turnId, isFirstChunk, isLastChunk)
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "pushAudioSync failed", e)
+            false
+        }
+    }
+
+    /**
+     * Disconnect the pipeline. Tears down AudioTrack, write thread, etc.
+     */
+    fun disconnect(promise: expo.modules.kotlin.Promise) {
+        try {
+            pipeline?.disconnect()
+            pipeline = null
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "disconnect failed", e)
+            promise.reject("PIPELINE_DISCONNECT_ERROR", e.message ?: "Unknown error", e)
+        }
+    }
+
+    /**
+     * Invalidate the current turn — discards stale audio in the jitter buffer.
+     *
+     * Options map:
+     *   - `turnId` (String) — the new turn identifier
+     */
+    fun invalidateTurn(options: Map<String, Any?>, promise: expo.modules.kotlin.Promise) {
+        try {
+            val turnId = options["turnId"] as? String
+                ?: throw IllegalArgumentException("Missing 'turnId' field")
+
+            pipeline?.invalidateTurn(turnId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "invalidateTurn failed", e)
+            promise.reject("PIPELINE_INVALIDATE_ERROR", e.message ?: "Unknown error", e)
+        }
+    }
+
+    /**
+     * Get current pipeline telemetry as a Bundle (returned to JS as a map).
+     */
+    fun getTelemetry(): Bundle {
+        return pipeline?.getTelemetry() ?: Bundle().apply {
+            putString("state", PipelineState.IDLE.value)
+        }
+    }
+
+    /**
+     * Get current pipeline state string.
+     */
+    fun getState(): String {
+        return pipeline?.getState()?.value ?: PipelineState.IDLE.value
+    }
+
+    /**
+     * Log AudioTrack health — called from the device callback to capture
+     * track state at the moment of a route change.
+     */
+    fun logAudioTrackHealth(trigger: String) {
+        pipeline?.logTrackHealth(trigger) ?: Log.d(TAG, "logAudioTrackHealth($trigger) — no pipeline connected")
+    }
+
+    /**
+     * Destroy the integration — called from OnDestroy / destroy().
+     */
+    fun destroy() {
+        pipeline?.disconnect()
+        pipeline = null
+    }
+
+    // ════════════════════════════════════════════════════════════════════
+    // PipelineListener implementation → Expo bridge events
+    // ════════════════════════════════════════════════════════════════════
+
+    override fun onStateChanged(state: PipelineState) {
+        sendEvent(EVENT_STATE_CHANGED, Bundle().apply {
+            putString("state", state.value)
+        })
+    }
+
+    override fun onPlaybackStarted(turnId: String) {
+        sendEvent(EVENT_PLAYBACK_STARTED, Bundle().apply {
+            putString("turnId", turnId)
+        })
+    }
+
+    override fun onError(code: String, message: String) {
+        sendEvent(EVENT_ERROR, Bundle().apply {
+            putString("code", code)
+            putString("message", message)
+        })
+    }
+
+    override fun onZombieDetected(playbackHead: Long, stalledMs: Long) {
+        sendEvent(EVENT_ZOMBIE_DETECTED, Bundle().apply {
+            putLong("playbackHead", playbackHead)
+            putLong("stalledMs", stalledMs)
+        })
+    }
+
+    override fun onUnderrun(count: Int) {
+        sendEvent(EVENT_UNDERRUN, Bundle().apply {
+            putInt("count", count)
+        })
+    }
+
+    override fun onDrained(turnId: String) {
+        sendEvent(EVENT_DRAINED, Bundle().apply {
+            putString("turnId", turnId)
+        })
+    }
+
+    override fun onAudioFocusLost() {
+        sendEvent(EVENT_AUDIO_FOCUS_LOST, Bundle())
+    }
+
+    override fun onAudioFocusResumed() {
+        sendEvent(EVENT_AUDIO_FOCUS_RESUMED, Bundle())
+    }
+
+    // ── Helper ──────────────────────────────────────────────────────────
+
+    private fun sendEvent(eventName: String, params: Bundle) {
+        try {
+            eventSender.sendExpoEvent(eventName, params)
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to send event $eventName", e)
+        }
+    }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build')

package/build/ExpoPlayAudioStreamModule.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=ExpoPlayAudioStreamModule.d.ts.map

package/build/ExpoPlayAudioStreamModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoPlayAudioStreamModule.d.ts","sourceRoot":"","sources":["../src/ExpoPlayAudioStreamModule.ts"],"names":[],"mappings":";AAIA,wBAA0D"}

package/build/ExpoPlayAudioStreamModule.js

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('ExpoPlayAudioStream');
+//# sourceMappingURL=ExpoPlayAudioStreamModule.js.map

package/build/ExpoPlayAudioStreamModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoPlayAudioStreamModule.js","sourceRoot":"","sources":["../src/ExpoPlayAudioStreamModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,kEAAkE;AAClE,4EAA4E;AAC5E,eAAe,mBAAmB,CAAC,qBAAqB,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\n\n// It loads the native module object from the JSI or falls back to\n// the bridge module (from NativeModulesProxy) if the remote debugger is on.\nexport default requireNativeModule('ExpoPlayAudioStream');\n"]}

package/build/events.d.ts

@@ -0,0 +1,36 @@
+import { type EventSubscription } from "expo-modules-core";
+export type Subscription = EventSubscription;
+export interface AudioEventPayload {
+    encoded?: string;
+    buffer?: Float32Array;
+    fileUri: string;
+    lastEmittedSize: number;
+    position: number;
+    deltaSize: number;
+    totalSize: number;
+    mimeType: string;
+    streamUuid: string;
+    soundLevel?: number;
+}
+export type SoundChunkPlayedEventPayload = {
+    isFinal: boolean;
+};
+export declare const DeviceReconnectedReasons: {
+    readonly newDeviceAvailable: "newDeviceAvailable";
+    readonly oldDeviceUnavailable: "oldDeviceUnavailable";
+    readonly unknown: "unknown";
+};
+export type DeviceReconnectedReason = (typeof DeviceReconnectedReasons)[keyof typeof DeviceReconnectedReasons];
+export type DeviceReconnectedEventPayload = {
+    reason: DeviceReconnectedReason;
+};
+export declare const AudioEvents: {
+    AudioData: string;
+    SoundChunkPlayed: string;
+    SoundStarted: string;
+    DeviceReconnected: string;
+};
+export declare function addAudioEventListener(listener: (event: AudioEventPayload) => Promise<void>): EventSubscription;
+export declare function addSoundChunkPlayedListener(listener: (event: SoundChunkPlayedEventPayload) => Promise<void>): EventSubscription;
+export declare function subscribeToEvent<T extends unknown>(eventName: string, listener: (event: T | undefined) => Promise<void>): EventSubscription;
+//# sourceMappingURL=events.d.ts.map

package/build/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGzE,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAC;AAM7C,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAE3E,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,EAAE,uBAAuB,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC;AAEF,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,GACpD,iBAAiB,CAEnB;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC,IAAI,CAAC,GAC/D,iBAAiB,CAEnB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAChD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAChD,iBAAiB,CAEnB"}

package/build/events.js

@@ -0,0 +1,25 @@
+// packages/expo-audio-stream/src/events.ts
+import { EventEmitter } from "expo-modules-core";
+import ExpoPlayAudioStreamModule from "./ExpoPlayAudioStreamModule";
+const emitter = new EventEmitter(ExpoPlayAudioStreamModule);
+export const DeviceReconnectedReasons = {
+    newDeviceAvailable: "newDeviceAvailable",
+    oldDeviceUnavailable: "oldDeviceUnavailable",
+    unknown: "unknown",
+};
+export const AudioEvents = {
+    AudioData: "AudioData",
+    SoundChunkPlayed: "SoundChunkPlayed",
+    SoundStarted: "SoundStarted",
+    DeviceReconnected: "DeviceReconnected",
+};
+export function addAudioEventListener(listener) {
+    return emitter.addListener("AudioData", listener);
+}
+export function addSoundChunkPlayedListener(listener) {
+    return emitter.addListener("SoundChunkPlayed", listener);
+}
+export function subscribeToEvent(eventName, listener) {
+    return emitter.addListener(eventName, listener);
+}
+//# sourceMappingURL=events.js.map

package/build/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAE3C,OAAO,EAAE,YAAY,EAA0B,MAAM,mBAAmB,CAAC;AAKzE,OAAO,yBAAyB,MAAM,6BAA6B,CAAC;AAEpE,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,yBAAyB,CAAC,CAAC;AAmB5D,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,kBAAkB,EAAE,oBAAoB;IACxC,oBAAoB,EAAE,sBAAsB;IAC5C,OAAO,EAAE,SAAS;CACV,CAAC;AASX,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,SAAS,EAAE,WAAW;IACtB,gBAAgB,EAAE,kBAAkB;IACpC,YAAY,EAAE,cAAc;IAC5B,iBAAiB,EAAE,mBAAmB;CACvC,CAAC;AAEF,MAAM,UAAU,qBAAqB,CACnC,QAAqD;IAErD,OAAQ,OAAe,CAAC,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,2BAA2B,CACzC,QAAgE;IAEhE,OAAQ,OAAe,CAAC,WAAW,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;AACpE,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,SAAiB,EACjB,QAAiD;IAEjD,OAAQ,OAAe,CAAC,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;AAC3D,CAAC","sourcesContent":["// packages/expo-audio-stream/src/events.ts\n\nimport { EventEmitter, type EventSubscription } from \"expo-modules-core\";\n\n// Type alias for backwards compatibility\nexport type Subscription = EventSubscription;\n\nimport ExpoPlayAudioStreamModule from \"./ExpoPlayAudioStreamModule\";\n\nconst emitter = new EventEmitter(ExpoPlayAudioStreamModule);\n\nexport interface AudioEventPayload {\n  encoded?: string;\n  buffer?: Float32Array;\n  fileUri: string;\n  lastEmittedSize: number;\n  position: number;\n  deltaSize: number;\n  totalSize: number;\n  mimeType: string;\n  streamUuid: string;\n  soundLevel?: number;\n}\n\nexport type SoundChunkPlayedEventPayload = {\n  isFinal: boolean;\n};\n\nexport const DeviceReconnectedReasons = {\n  newDeviceAvailable: \"newDeviceAvailable\",\n  oldDeviceUnavailable: \"oldDeviceUnavailable\",\n  unknown: \"unknown\",\n} as const;\n\nexport type DeviceReconnectedReason =\n  (typeof DeviceReconnectedReasons)[keyof typeof DeviceReconnectedReasons];\n\nexport type DeviceReconnectedEventPayload = {\n  reason: DeviceReconnectedReason;\n};\n\nexport const AudioEvents = {\n  AudioData: \"AudioData\",\n  SoundChunkPlayed: \"SoundChunkPlayed\",\n  SoundStarted: \"SoundStarted\",\n  DeviceReconnected: \"DeviceReconnected\",\n};\n\nexport function addAudioEventListener(\n  listener: (event: AudioEventPayload) => Promise<void>\n): EventSubscription {\n  return (emitter as any).addListener(\"AudioData\", listener);\n}\n\nexport function addSoundChunkPlayedListener(\n  listener: (event: SoundChunkPlayedEventPayload) => Promise<void>\n): EventSubscription {\n  return (emitter as any).addListener(\"SoundChunkPlayed\", listener);\n}\n\nexport function subscribeToEvent<T extends unknown>(\n  eventName: string,\n  listener: (event: T | undefined) => Promise<void>\n): EventSubscription {\n  return (emitter as any).addListener(eventName, listener);\n}\n"]}