@edkimmel/expo-audio-stream 0.2.0

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

@@ -0,0 +1,280 @@
+package expo.modules.audiostream
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.AudioDeviceCallback
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.core.app.ActivityCompat
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.audiostream.pipeline.PipelineIntegration
+
+
+
+class ExpoPlayAudioStreamModule : Module(), EventSender {
+    private lateinit var audioRecorderManager: AudioRecorderManager
+    private lateinit var audioPlaybackManager: AudioPlaybackManager
+    private lateinit var audioManager: AudioManager
+    private lateinit var pipelineIntegration: PipelineIntegration
+
+    // Ensure callbacks are delivered on the main thread
+    private val mainHandler by lazy { Handler(Looper.getMainLooper()) }
+
+    private val reportedGroups = mutableSetOf<String>()
+
+    /** Map every device type to a logical group key */
+    private fun groupKey(type: Int): String = when (type) {
+        AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+        AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> "BLUETOOTH"
+        AudioDeviceInfo.TYPE_WIRED_HEADSET,
+        AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+        AudioDeviceInfo.TYPE_USB_HEADSET   -> "WIRED"
+        else -> type.toString() // fallback, treats every other type separately
+    }
+
+    // We care about these types – includes both SCO and A2DP but we will collapse them into one group
+    private val interestingTypes = setOf(
+        AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+        AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+        AudioDeviceInfo.TYPE_WIRED_HEADSET,
+        AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+        AudioDeviceInfo.TYPE_USB_HEADSET
+    )
+
+    private val audioCallCallback = object : AudioDeviceCallback() {
+        override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
+            val descriptions = addedDevices?.map { "${it.productName} (type=${it.type})" } ?: emptyList()
+            Log.d("ExpoAudioCallback", "onAudioDevicesAdded: $descriptions")
+
+            val firstOfGroup = addedDevices?.filter { d ->
+                d.type in interestingTypes && reportedGroups.add(groupKey(d.type))
+            }
+            if (firstOfGroup?.isNotEmpty()==true) {
+                val matched = firstOfGroup.map { "${it.productName} (type=${it.type})" }
+                Log.d("ExpoAudioCallback", "AudioDeviceCallback ➜ ADDED (interesting): $matched")
+                pipelineIntegration.logAudioTrackHealth("device_added")
+                val params = Bundle()
+                params.putString("reason", "newDeviceAvailable")
+                sendExpoEvent(Constants.DEVICE_RECONNECTED_EVENT_NAME, params)
+            }
+        }
+
+        override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
+            val descriptions = removedDevices?.map { "${it.productName} (type=${it.type})" } ?: emptyList()
+            Log.d("ExpoAudioCallback", "onAudioDevicesRemoved: $descriptions")
+
+            val lastOfGroup = removedDevices?.filter { d ->
+                d.type in interestingTypes && reportedGroups.remove(groupKey(d.type))
+            }
+            if (lastOfGroup?.isNotEmpty() == true) {
+                val matched = lastOfGroup.map { "${it.productName} (type=${it.type})" }
+                Log.d("ExpoAudioCallback", "AudioDeviceCallback ➜ REMOVED (interesting): $matched")
+                pipelineIntegration.logAudioTrackHealth("device_removed")
+                audioPlaybackManager.stopPlayback(null)
+                val params = Bundle()
+                params.putString("reason", "oldDeviceUnavailable")
+                sendExpoEvent(Constants.DEVICE_RECONNECTED_EVENT_NAME, params)
+            }
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    @RequiresApi(Build.VERSION_CODES.R)
+    override fun definition() = ModuleDefinition {
+        Name("ExpoPlayAudioStream")
+
+        Events(
+            Constants.AUDIO_EVENT_NAME,
+            Constants.SOUND_CHUNK_PLAYED_EVENT_NAME,
+            Constants.SOUND_STARTED_EVENT_NAME,
+            Constants.DEVICE_RECONNECTED_EVENT_NAME,
+            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
+        )
+
+        // Initialize managers for playback and for recording
+        initializeManager()
+        initializePlaybackManager()
+        initializePipeline()
+
+        OnCreate {
+            audioManager = appContext.reactContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+            audioManager.registerAudioDeviceCallback(audioCallCallback, mainHandler)
+        }
+
+        OnDestroy {
+            reportedGroups.clear()
+            audioManager.unregisterAudioDeviceCallback(audioCallCallback)
+            // Module is being destroyed (app shutdown)
+            // Just clean up resources without reinitialization
+            pipelineIntegration.destroy()
+            audioPlaybackManager.runOnDispose()
+            audioRecorderManager.release()
+        }
+
+        Function("destroy") {
+            // User explicitly called destroy - clean up and reinitialize for reuse
+            pipelineIntegration.destroy()
+            audioPlaybackManager.runOnDispose()
+            audioRecorderManager.release()
+
+            // Reinitialize all managers so the module can be used again
+            initializeManager()
+            initializePlaybackManager()
+            initializePipeline()
+        }
+
+        AsyncFunction("requestPermissionsAsync") { promise: Promise ->
+            Permissions.askForPermissionsWithPermissionsManager(
+                appContext.permissions,
+                promise,
+                Manifest.permission.RECORD_AUDIO
+            )
+        }
+
+        AsyncFunction("getPermissionsAsync") { promise: Promise ->
+            Permissions.getPermissionsWithPermissionsManager(
+                appContext.permissions,
+                promise,
+                Manifest.permission.RECORD_AUDIO
+            )
+        }
+
+        AsyncFunction("playSound") { chunk: String, turnId: String, encoding: String?, promise: Promise ->
+            val pcmEncoding = when (encoding) {
+                "pcm_f32le" -> PCMEncoding.PCM_F32LE
+                "pcm_s16le", null -> PCMEncoding.PCM_S16LE
+                else -> {
+                    Log.d(Constants.TAG, "Unsupported encoding: $encoding, defaulting to PCM_S16LE")
+                    PCMEncoding.PCM_S16LE
+                }
+            }
+            audioPlaybackManager.playAudio(chunk, turnId, promise, pcmEncoding)
+        }
+
+        AsyncFunction("stopSound") { promise: Promise -> audioPlaybackManager.stopPlayback(promise) }
+
+        AsyncFunction("clearSoundQueueByTurnId") { turnId: String, promise: Promise ->
+            audioPlaybackManager.setCurrentTurnId(turnId)
+            promise.resolve(null)
+        }
+
+        AsyncFunction("startMicrophone") { options: Map<String, Any?>, promise: Promise ->
+            audioRecorderManager.startRecording(options, promise)
+        }
+
+        AsyncFunction("stopMicrophone") { promise: Promise ->
+            audioRecorderManager.stopRecording(promise)
+        }
+
+        Function("toggleSilence") { isSilent: Boolean ->
+            // Just toggle silence without returning any value
+            audioRecorderManager.toggleSilence(isSilent)
+        }
+
+        AsyncFunction("setSoundConfig") { config: Map<String, Any?>, promise: Promise ->
+            val useDefault = config["useDefault"] as? Boolean ?: false
+
+            if (useDefault) {
+                // Reset to default configuration
+                Log.d(Constants.TAG, "Resetting sound configuration to default values")
+                audioPlaybackManager.resetConfigToDefault(promise)
+            } else {
+                // Extract configuration values
+                val sampleRate = (config["sampleRate"] as? Number)?.toInt() ?: 16000
+                val playbackModeString = config["playbackMode"] as? String ?: "regular"
+
+                // Convert string playback mode to enum
+                val playbackMode = when (playbackModeString) {
+                    "voiceProcessing" -> PlaybackMode.VOICE_PROCESSING
+                    "conversation" -> PlaybackMode.CONVERSATION
+                    else -> PlaybackMode.REGULAR
+                }
+
+                // Create a new SoundConfig object
+                val soundConfig = SoundConfig(sampleRate = sampleRate, playbackMode = playbackMode)
+
+                // Update the sound player configuration
+                Log.d(Constants.TAG, "Setting sound configuration - sampleRate: $sampleRate, playbackMode: $playbackModeString")
+                audioPlaybackManager.updateConfig(soundConfig, promise)
+            }
+        }
+
+        // ── Native Audio Pipeline V3 ────────────────────────────────────
+
+        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()
+        }
+
+    }
+    private fun initializeManager() {
+        val androidContext =
+            appContext.reactContext ?: throw IllegalStateException("Android context not available")
+        val permissionUtils = PermissionUtils(androidContext)
+        val audioEncoder = AudioDataEncoder()
+        val audioEffectsManager = AudioEffectsManager()
+        audioRecorderManager =
+            AudioRecorderManager(
+                permissionUtils,
+                audioEncoder,
+                this,
+                audioEffectsManager
+            )
+    }
+
+    private fun initializePlaybackManager() {
+        audioPlaybackManager = AudioPlaybackManager(this)
+    }
+
+    private fun initializePipeline() {
+        val ctx = appContext.reactContext
+            ?: throw IllegalStateException("Android context not available")
+        pipelineIntegration = PipelineIntegration(ctx, this)
+    }
+
+    override fun sendExpoEvent(eventName: String, params: Bundle) {
+        Log.d(Constants.TAG, "Sending event EXPO: $eventName")
+        this@ExpoPlayAudioStreamModule.sendEvent(eventName, params)
+    }
+}

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

@@ -0,0 +1,16 @@
+package expo.modules.audiostream
+
+import android.content.Context
+import android.content.pm.PackageManager
+import androidx.core.content.ContextCompat
+
+class PermissionUtils(private val context: Context) {
+
+    /**
+     * Checks if the recording permission has been granted.
+     * @return Boolean indicating whether the RECORD_AUDIO permission is granted.
+     */
+    fun checkRecordingPermission(): Boolean {
+        return ContextCompat.checkSelfPermission(context, android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
+    }
+}

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

@@ -0,0 +1,60 @@
+package expo.modules.audiostream
+
+data class RecordingConfig(
+    val sampleRate: Int = Constants.DEFAULT_SAMPLE_RATE,
+    val channels: Int = 1,
+    val encoding: String = "pcm_16bit",
+    val interval: Long = Constants.DEFAULT_INTERVAL,
+    val pointsPerSecond: Double = 20.0
+) {
+    /**
+     * Validates the recording configuration
+     * @return Error information if invalid, null if valid
+     */
+    fun validate(): ValidationResult? {
+        // Check sample rate
+        if (sampleRate !in listOf(16000, 24000, 44100, 48000)) {
+            return ValidationResult(
+                "INVALID_SAMPLE_RATE",
+                "Sample rate must be one of 16000, 24000, 44100, or 48000 Hz"
+            )
+        }
+        
+        // Check channels
+        if (channels !in 1..2) {
+            return ValidationResult(
+                "INVALID_CHANNELS",
+                "Channels must be either 1 (Mono) or 2 (Stereo)"
+            )
+        }
+        
+        // All checks passed
+        return null
+    }
+    
+    companion object {
+        /**
+         * Creates a RecordingConfig from options map
+         * @param options Map containing configuration options
+         * @return New RecordingConfig instance
+         */
+        fun fromOptions(options: Map<String, Any?>): RecordingConfig {
+            return RecordingConfig(
+                sampleRate = (options["sampleRate"] as? Number)?.toInt() ?: Constants.DEFAULT_SAMPLE_RATE,
+                channels = (options["channels"] as? Number)?.toInt() ?: 1,
+                encoding = options["encoding"] as? String ?: "pcm_16bit",
+                interval = (options["interval"] as? Number)?.toLong() ?: Constants.DEFAULT_INTERVAL,
+                pointsPerSecond = (options["pointsPerSecond"] as? Number)?.toDouble() ?: 20.0
+            )
+        }
+    }
+}
+
+/**
+ * Data class to hold validation error information
+ */
+data class ValidationResult(
+    val code: String,
+    val message: String
+)
+

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

@@ -0,0 +1,46 @@
+package expo.modules.audiostream
+
+/**
+ * Defines different playback modes for audio processing
+ */
+enum class PlaybackMode {
+    /**
+     * Regular playback mode for standard audio playback
+     */
+    REGULAR,
+    
+    /**
+     * Conversation mode optimized for speech
+     */
+    CONVERSATION,
+    
+    /**
+     * Voice processing mode with enhanced voice quality
+     */
+    VOICE_PROCESSING
+}
+
+/**
+ * Configuration for audio playback settings
+ */
+data class SoundConfig(
+    /**
+     * The sample rate for audio playback in Hz
+     */
+    val sampleRate: Int = 44100,
+    
+    /**
+     * The playback mode (regular, conversation, or voiceProcessing)
+     */
+    val playbackMode: PlaybackMode = PlaybackMode.REGULAR
+) {
+    companion object {
+        /**
+         * Default configuration with standard settings
+         */
+        val DEFAULT = SoundConfig(
+            sampleRate = 44100,
+            playbackMode = PlaybackMode.REGULAR
+        )
+    }
+}