@siteed/expo-audio-studio 2.12.3 → 2.13.0

package/CHANGELOG.md

@@ -8,6 +8,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
+## [2.13.0] - 2025-06-09
+### Changed
+- feat(expo-audio-studio): enhance device detection and management system ([97ceef0](https://github.com/deeeed/expo-audio-stream/commit/97ceef003ddb8eb5246cda8a5a00ddc75bf665a0))
 ## [2.12.3] - 2025-06-07
 ### Changed
 - refactor(expo-audio-studio): adjust audio focus request timing in AudioRecorderManager ([317367c](https://github.com/deeeed/expo-audio-stream/commit/317367cb29fa09016aa73884f2f51e9cfdee1086))
@@ -304,7 +307,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Feature: Audio features extraction during recording.
 - Feature: Consistent WAV PCM recording format across all platforms.
 
-[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.3...HEAD
+[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.13.0...HEAD
+[2.13.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.3...@siteed/expo-audio-studio@2.13.0
 [2.12.3]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.2...@siteed/expo-audio-studio@2.12.3
 [2.12.2]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.1...@siteed/expo-audio-studio@2.12.2
 [2.12.1]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.0...@siteed/expo-audio-studio@2.12.1

package/android/build.gradle

@@ -32,6 +32,7 @@ buildscript {
 
   repositories {
     mavenCentral()
+    google()
   }
 
   dependencies {
@@ -91,12 +92,22 @@ android {
 
 repositories {
   mavenCentral()
+  google()
 }
 
 dependencies {
   implementation project(':expo-modules-core')
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
 
+  // Add AndroidX dependencies
+  implementation 'androidx.core:core-ktx:1.10.1'
+  implementation 'androidx.annotation:annotation:1.6.0'
+  implementation 'androidx.appcompat:appcompat:1.6.1'
+  
+  // Add Kotlinx Coroutines for main code
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+
   // Add testing dependencies
   testImplementation 'junit:junit:4.13.2'
   testImplementation 'org.jetbrains.kotlin:kotlin-test:1.8.10'

package/android/src/main/AndroidManifest.xml

@@ -6,6 +6,14 @@
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE"/>
     <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+    
+    <!-- Bluetooth permissions for device detection -->
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+    
+    <!-- USB permission for USB device detection -->
+    <uses-permission android:name="android.permission.USB_PERMISSION" />
 
     <application>
         <receiver 

package/android/src/main/java/net/siteed/audiostream/AudioDeviceManager.kt

@@ -21,6 +21,7 @@ import net.siteed.audiostream.LogUtils
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
 
 /**
  * Constants not available in all Android versions
@@ -62,6 +63,12 @@ class AudioDeviceManager(private val context: Context) {
     // Delegate for handling device disconnection
     var delegate: AudioDeviceManagerDelegate? = null
     
+    // Simple callback for device connections
+    var onDeviceConnected: ((String) -> Unit)? = null
+    
+    // Simple callback for device disconnections
+    var onDeviceDisconnected: ((String) -> Unit)? = null
+    
     // Audio manager for accessing device information
     private val audioManager: AudioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
     
@@ -1113,6 +1120,9 @@ class AudioDeviceManager(private val context: Context) {
                     addAction(UsbManager.ACTION_USB_ACCESSORY_ATTACHED)
                     addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED)
                 }
+                
+                // Bluetooth SCO state changes - to detect when microphone becomes available
+                addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED)
             }
             
             deviceReceiver = object : BroadcastReceiver() {
@@ -1153,6 +1163,28 @@ class AudioDeviceManager(private val context: Context) {
                                         }
                                     }
                                 }
+                            } else if (state == 1) { // Plugged in
+                                LogUtils.d(CLASS_NAME, "Wired headset connected: $name")
+                                
+                                // For M+ find the actual new device
+                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                    // Find the newly connected wired device
+                                    val audioDevices = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)
+                                    val wiredDevice = audioDevices.firstOrNull { 
+                                        (it.type == AudioDeviceInfo.TYPE_WIRED_HEADSET || 
+                                         it.type == AudioDeviceInfo.TYPE_WIRED_HEADPHONES) &&
+                                        getDeviceName(it).contains(name, ignoreCase = true)
+                                    }
+                                    
+                                    if (wiredDevice != null) {
+                                        val connectedDeviceId = wiredDevice.id.toString()
+                                        LogUtils.d(CLASS_NAME, "Found connected wired device: $name (ID: $connectedDeviceId)")
+                                        handleDeviceConnection(connectedDeviceId)
+                                    }
+                                } else {
+                                    // Legacy handling for older Android
+                                    handleDeviceConnection("1")
+                                }
                             }
                         }
                         
@@ -1184,6 +1216,59 @@ class AudioDeviceManager(private val context: Context) {
                             }
                         }
                         
+                        BluetoothDevice.ACTION_ACL_CONNECTED -> {
+                            val device = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                                intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
+                            } else {
+                                @Suppress("DEPRECATION")
+                                intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+                            }
+                            
+                            if (device != null) {
+                                LogUtils.d(CLASS_NAME, "Bluetooth device connected: ${device.name}")
+                                
+                                // For M+ find the actual new device
+                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                    val actualDevice = findBluetoothDevice(device)
+                                    if (actualDevice != null) {
+                                        val connectedDeviceId = actualDevice.id.toString()
+                                        LogUtils.d(CLASS_NAME, "Found connected Bluetooth device: ${device.name} (ID: $connectedDeviceId)")
+                                        handleDeviceConnection(connectedDeviceId)
+                                    } else {
+                                        LogUtils.d(CLASS_NAME, "Bluetooth device ${device.name} connected but not found in audio device list - attempting to activate SCO")
+                                        
+                                        // Try to activate Bluetooth SCO to make microphone available
+                                        if (!audioManager.isBluetoothScoOn) {
+                                            LogUtils.d(CLASS_NAME, "Starting Bluetooth SCO to activate microphone for ${device.name}")
+                                            audioManager.startBluetoothSco()
+                                            
+                                            // Give SCO time to activate, then check again
+                                            coroutineScope.launch {
+                                                delay(2000) // Wait 2 seconds
+                                                
+                                                val scoDevice = findBluetoothDevice(device)
+                                                if (scoDevice != null) {
+                                                    val activatedDeviceId = scoDevice.id.toString()
+                                                    LogUtils.d(CLASS_NAME, "Bluetooth SCO activated for device: ${device.name} (ID: $activatedDeviceId)")
+                                                    handleDeviceConnection(activatedDeviceId)
+                                                } else {
+                                                    LogUtils.d(CLASS_NAME, "Bluetooth SCO didn't activate microphone for ${device.name}")
+                                                    // Send generic connection event anyway
+                                                    handleDeviceConnection("bluetooth:${device.address}")
+                                                }
+                                            }
+                                        } else {
+                                            // SCO already on, send generic event
+                                            handleDeviceConnection("bluetooth:${device.address}")
+                                        }
+                                    }
+                                } else {
+                                    // Legacy handling for older Android
+                                    handleDeviceConnection("2")
+                                }
+                            }
+                        }
+                        
                         BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
                             val device = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                                 intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
@@ -1213,42 +1298,117 @@ class AudioDeviceManager(private val context: Context) {
                             val state = intent.getIntExtra(BluetoothAdapter.EXTRA_CONNECTION_STATE, -1)
                             logAudioState()
                             
-                            // Only handle disconnect events and only for HEADSET profile (relevant for audio)
-                            if (state == BluetoothAdapter.STATE_DISCONNECTED) {
-                                val device = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                                    intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
-                                } else {
-                                    @Suppress("DEPRECATION")
-                                    intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
-                                }
-                                
-                                if (device != null) {
-                                    deviceId = "2" // Legacy ID for bluetooth
-                                    deviceName = device.name
-                                    deviceType = DEVICE_TYPE_BLUETOOTH
+                            when (state) {
+                                BluetoothAdapter.STATE_CONNECTED -> {
+                                    val device = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                                        intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
+                                    } else {
+                                        @Suppress("DEPRECATION")
+                                        intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+                                    }
                                     
-                                    // For M+ get the actual ID
-                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                                        val actualDevice = findBluetoothDevice(device)
-                                        if (actualDevice != null) {
-                                            deviceId = actualDevice.id.toString()
+                                    if (device != null) {
+                                        LogUtils.d(CLASS_NAME, "Bluetooth profile connected: ${device.name}")
+                                        
+                                        // For M+ find the actual new device
+                                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                            val actualDevice = findBluetoothDevice(device)
+                                            if (actualDevice != null) {
+                                                val connectedDeviceId = actualDevice.id.toString()
+                                                LogUtils.d(CLASS_NAME, "Found connected Bluetooth profile device: ${device.name} (ID: $connectedDeviceId)")
+                                                handleDeviceConnection(connectedDeviceId)
+                                            } else {
+                                                LogUtils.d(CLASS_NAME, "Bluetooth profile ${device.name} connected but not found in audio device list - attempting to activate SCO")
+                                                
+                                                // Try to activate Bluetooth SCO to make microphone available
+                                                if (!audioManager.isBluetoothScoOn) {
+                                                    LogUtils.d(CLASS_NAME, "Starting Bluetooth SCO to activate microphone for ${device.name}")
+                                                    audioManager.startBluetoothSco()
+                                                    
+                                                    // Give SCO time to activate, then check again
+                                                    coroutineScope.launch {
+                                                        delay(2000) // Wait 2 seconds
+                                                        
+                                                        val scoDevice = findBluetoothDevice(device)
+                                                        if (scoDevice != null) {
+                                                            val activatedDeviceId = scoDevice.id.toString()
+                                                            LogUtils.d(CLASS_NAME, "Bluetooth SCO activated for device: ${device.name} (ID: $activatedDeviceId)")
+                                                            handleDeviceConnection(activatedDeviceId)
+                                                        } else {
+                                                            LogUtils.d(CLASS_NAME, "Bluetooth SCO didn't activate microphone for ${device.name}")
+                                                            // Send generic connection event anyway
+                                                            handleDeviceConnection("bluetooth:${device.address}")
+                                                        }
+                                                    }
+                                                } else {
+                                                    // SCO already on, send generic event
+                                                    handleDeviceConnection("bluetooth:${device.address}")
+                                                }
+                                            }
+                                        } else {
+                                            // Legacy handling for older Android
+                                            handleDeviceConnection("2")
                                         }
                                     }
+                                }
+                                
+                                BluetoothAdapter.STATE_DISCONNECTED -> {
+                                    val device = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                                        intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
+                                    } else {
+                                        @Suppress("DEPRECATION")
+                                        intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+                                    }
                                     
-                                    LogUtils.d(CLASS_NAME, "Bluetooth profile disconnected: ${device.name}, using ID: $deviceId")
-                                } 
-                                // No device info, check if our last device was bluetooth
-                                else if (lastSelectedDeviceId != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                                    val lastDeviceInfo = findDeviceById(lastSelectedDeviceId!!)
-                                    
-                                    if (lastDeviceInfo?.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO) {
-                                        deviceId = lastSelectedDeviceId
-                                        LogUtils.d(CLASS_NAME, "Bluetooth profile disconnected, using last selected device ID: $deviceId")
+                                    if (device != null) {
+                                        deviceId = "2" // Legacy ID for bluetooth
+                                        deviceName = device.name
+                                        deviceType = DEVICE_TYPE_BLUETOOTH
+                                        
+                                        // For M+ get the actual ID
+                                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                            val actualDevice = findBluetoothDevice(device)
+                                            if (actualDevice != null) {
+                                                deviceId = actualDevice.id.toString()
+                                            }
+                                        }
+                                        
+                                        LogUtils.d(CLASS_NAME, "Bluetooth profile disconnected: ${device.name}, using ID: $deviceId")
+                                    } 
+                                    // No device info, check if our last device was bluetooth
+                                    else if (lastSelectedDeviceId != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                        val lastDeviceInfo = findDeviceById(lastSelectedDeviceId!!)
+                                        
+                                        if (lastDeviceInfo?.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO) {
+                                            deviceId = lastSelectedDeviceId
+                                            LogUtils.d(CLASS_NAME, "Bluetooth profile disconnected, using last selected device ID: $deviceId")
+                                        }
                                     }
                                 }
                             }
                         }
                         
+                        UsbManager.ACTION_USB_DEVICE_ATTACHED, UsbManager.ACTION_USB_ACCESSORY_ATTACHED -> {
+                            LogUtils.d(CLASS_NAME, "USB device attached")
+                            
+                            // For M+ find newly connected USB audio devices
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                val audioDevices = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)
+                                val usbDevice = audioDevices.firstOrNull { 
+                                    it.type == AudioDeviceInfo.TYPE_USB_DEVICE || 
+                                    it.type == AudioDeviceInfo.TYPE_USB_HEADSET || 
+                                    it.type == AudioDeviceInfo.TYPE_USB_ACCESSORY
+                                }
+                                
+                                if (usbDevice != null) {
+                                    val connectedDeviceId = usbDevice.id.toString()
+                                    val deviceName = getDeviceName(usbDevice)
+                                    LogUtils.d(CLASS_NAME, "Found connected USB audio device: $deviceName (ID: $connectedDeviceId)")
+                                    handleDeviceConnection(connectedDeviceId)
+                                }
+                            }
+                        }
+                        
                         UsbManager.ACTION_USB_DEVICE_DETACHED, UsbManager.ACTION_USB_ACCESSORY_DETACHED -> {
                             LogUtils.d(CLASS_NAME, "USB device detached")
                             
@@ -1266,28 +1426,74 @@ class AudioDeviceManager(private val context: Context) {
                                 }
                             }
                         }
+                        
+                        AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED -> {
+                            val scoState = intent.getIntExtra(AudioManager.EXTRA_SCO_AUDIO_STATE, -1)
+                            LogUtils.d(CLASS_NAME, "Bluetooth SCO state changed: $scoState")
+                            
+                            when (scoState) {
+                                AudioManager.SCO_AUDIO_STATE_CONNECTED -> {
+                                    LogUtils.d(CLASS_NAME, "Bluetooth SCO connected - microphone available")
+                                    
+                                    // Check if any new Bluetooth SCO devices appeared
+                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                        val audioDevices = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)
+                                        val bluetoothScoDevices = audioDevices.filter { 
+                                            it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO 
+                                        }
+                                        
+                                        if (bluetoothScoDevices.isNotEmpty()) {
+                                            // Found Bluetooth SCO device(s), notify about the first one
+                                            val scoDevice = bluetoothScoDevices.first()
+                                            val scoDeviceId = scoDevice.id.toString()
+                                            val scoDeviceName = getDeviceName(scoDevice)
+                                            LogUtils.d(CLASS_NAME, "Found Bluetooth SCO device: $scoDeviceName (ID: $scoDeviceId)")
+                                            handleDeviceConnection(scoDeviceId)
+                                        }
+                                    }
+                                }
+                                
+                                AudioManager.SCO_AUDIO_STATE_DISCONNECTED -> {
+                                    LogUtils.d(CLASS_NAME, "Bluetooth SCO disconnected - microphone no longer available")
+                                    // Note: Device disconnection will be handled by other broadcasts
+                                }
+                                
+                                AudioManager.SCO_AUDIO_STATE_CONNECTING -> {
+                                    LogUtils.d(CLASS_NAME, "Bluetooth SCO connecting...")
+                                }
+                                
+                                else -> {
+                                    LogUtils.d(CLASS_NAME, "Bluetooth SCO state: $scoState")
+                                }
+                            }
+                        }
                     }
                     
-                    // If this is the currently selected device, notify delegate
-                    if (deviceId != null && deviceId == lastSelectedDeviceId) {
-                        LogUtils.d(CLASS_NAME, "Currently selected device disconnected: $deviceId")
+                    // Handle any device disconnection - send events to React Native for device list updates
+                    if (deviceId != null) {
+                        LogUtils.d(CLASS_NAME, "Device disconnected: $deviceId (selected: ${deviceId == lastSelectedDeviceId})")
+                        if (deviceName != null) {
+                            LogUtils.d(CLASS_NAME, "Device name: $deviceName, type: $deviceType")
+                        }
+                        
                         // Log the disconnection for debugging
                         logDeviceDisconnection(deviceId, action ?: "unknown")
                         
-                        // Launch a coroutine to call the suspend function
-                        coroutineScope.launch {
-                            try {
-                                handleDeviceDisconnection(deviceId)
-                            } catch (e: Exception) {
-                                LogUtils.e(CLASS_NAME, "Error handling device disconnection: ${e.message}", e)
+                        // Send device disconnection event to React Native (for UI updates)
+                        handleDeviceDisconnectionEvent(deviceId)
+                        
+                        // If this was the currently selected device, also notify delegate for recording interruption
+                        if (deviceId == lastSelectedDeviceId) {
+                            LogUtils.d(CLASS_NAME, "Currently selected device disconnected - notifying delegate: $deviceId")
+                            // Launch a coroutine to call the suspend function
+                            coroutineScope.launch {
+                                try {
+                                    handleDeviceDisconnection(deviceId)
+                                } catch (e: Exception) {
+                                    LogUtils.e(CLASS_NAME, "Error handling device disconnection: ${e.message}", e)
+                                }
                             }
                         }
-                    } else if (deviceId != null) {
-                        // Even if not our current device, log for debugging
-                        LogUtils.d(CLASS_NAME, "Device disconnected but not currently selected: $deviceId")
-                        if (deviceName != null) {
-                            LogUtils.d(CLASS_NAME, "Device name: $deviceName, type: $deviceType")
-                        }
                     }
                     
                     // Force refresh the device list
@@ -1498,4 +1704,22 @@ class AudioDeviceManager(private val context: Context) {
         LogUtils.d(CLASS_NAME, "Device disconnected: $deviceId. Pausing recording.")
         delegate?.onDeviceDisconnected(deviceId)
     }
+    
+    /**
+     * Handles audio device connection
+     */
+    private fun handleDeviceConnection(deviceId: String) {
+        LogUtils.d(CLASS_NAME, "Device connected: $deviceId")
+        onDeviceConnected?.invoke(deviceId)
+    }
+    
+    /**
+     * Handles audio device disconnection (for React Native events)
+     */
+    private fun handleDeviceDisconnectionEvent(deviceId: String) {
+        LogUtils.d(CLASS_NAME, "Device disconnected: $deviceId")
+        onDeviceDisconnected?.invoke(deviceId)
+    }
+    
+
 } 

package/android/src/main/java/net/siteed/audiostream/ExpoAudioStreamModule.kt

@@ -7,6 +7,7 @@ import android.os.Bundle
 import android.util.Log
 import android.content.pm.PackageManager
 import androidx.annotation.RequiresApi
+import androidx.core.content.ContextCompat
 import androidx.core.os.bundleOf
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.modules.Module
@@ -30,6 +31,7 @@ class ExpoAudioStreamModule : Module(), EventSender {
     private var enablePhoneStateHandling: Boolean = false // Default to false until we check manifest
     private var enableNotificationHandling: Boolean = false // Default to false until we check manifest
     private var enableBackgroundAudio: Boolean = false // Default to false until we check manifest
+    private var enableDeviceDetection: Boolean = false // Default to false until we check manifest
     private val coroutineScope = CoroutineScope(Dispatchers.Main)
 
     private val audioFileHandler by lazy { 
@@ -65,14 +67,19 @@ class ExpoAudioStreamModule : Module(), EventSender {
             // Check if background audio is enabled by looking for FOREGROUND_SERVICE_MICROPHONE permission
             enableBackgroundAudio = packageInfo.requestedPermissions?.contains(Manifest.permission.FOREGROUND_SERVICE_MICROPHONE) ?: false
             
+            // Check if device detection is enabled by looking for BLUETOOTH_CONNECT permission
+            enableDeviceDetection = packageInfo.requestedPermissions?.contains(Manifest.permission.BLUETOOTH_CONNECT) ?: false
+            
             LogUtils.d(CLASS_NAME, "Phone state handling ${if (enablePhoneStateHandling) "enabled" else "disabled"} based on manifest permissions")
             LogUtils.d(CLASS_NAME, "Notification handling ${if (enableNotificationHandling) "enabled" else "disabled"} based on manifest permissions")
             LogUtils.d(CLASS_NAME, "Background audio handling ${if (enableBackgroundAudio) "enabled" else "disabled"} based on manifest permissions")
+            LogUtils.d(CLASS_NAME, "Device detection ${if (enableDeviceDetection) "enabled" else "disabled"} based on manifest permissions")
         } catch (e: Exception) {
             LogUtils.e(CLASS_NAME, "Failed to check manifest permissions: ${e.message}", e)
             enablePhoneStateHandling = false
             enableNotificationHandling = false
             enableBackgroundAudio = false
+            enableDeviceDetection = false
         }
 
         Events(
@@ -91,6 +98,11 @@ class ExpoAudioStreamModule : Module(), EventSender {
             return Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE && enableBackgroundAudio
         }
 
+        // Helper function to check if device detection is enabled
+        fun isDeviceDetectionEnabled(): Boolean {
+            return enableDeviceDetection
+        }
+
         // Add device-related functions to the module
         
         // Gets available audio input devices with an optional refresh parameter
@@ -169,6 +181,8 @@ class ExpoAudioStreamModule : Module(), EventSender {
             return@Function mapOf("success" to success)
         }
 
+
+
         AsyncFunction("prepareRecording") { options: Map<String, Any?>, promise: Promise ->
             try {
                 // If notifications are requested but permission not in manifest, modify options
@@ -263,6 +277,15 @@ class ExpoAudioStreamModule : Module(), EventSender {
                     permissions.add(Manifest.permission.FOREGROUND_SERVICE_MICROPHONE)
                 }
 
+                // Add device detection permissions if device detection is enabled
+                if (isDeviceDetectionEnabled()) {
+                    // BLUETOOTH_CONNECT is needed on Android 12+ to access device names/addresses
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                        permissions.add(Manifest.permission.BLUETOOTH_CONNECT)
+                        LogUtils.d(CLASS_NAME, "Adding BLUETOOTH_CONNECT permission request for device detection")
+                    }
+                }
+
                 LogUtils.d(CLASS_NAME, "Requesting permissions: $permissions")
                 Permissions.askForPermissionsWithPermissionsManager(
                     appContext.permissions,
@@ -290,6 +313,14 @@ class ExpoAudioStreamModule : Module(), EventSender {
                 permissions.add(Manifest.permission.FOREGROUND_SERVICE_MICROPHONE)
             }
 
+            // Add device detection permissions if enabled
+            if (isDeviceDetectionEnabled()) {
+                // BLUETOOTH_CONNECT is needed on Android 12+ to access device names/addresses
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    permissions.add(Manifest.permission.BLUETOOTH_CONNECT)
+                }
+            }
+
             Permissions.getPermissionsWithPermissionsManager(
                 appContext.permissions,
                 promise,
@@ -909,7 +940,10 @@ class ExpoAudioStreamModule : Module(), EventSender {
         val audioDataEncoder = AudioDataEncoder()
         
         // Initialize AudioDeviceManager
+        LogUtils.d(CLASS_NAME, "🔧 Initializing AudioDeviceManager...")
+        LogUtils.d(CLASS_NAME, "🔧 Device detection enabled: $enableDeviceDetection")
         audioDeviceManager = AudioDeviceManager(context)
+        LogUtils.d(CLASS_NAME, "🔧 AudioDeviceManager initialized")
         
         // Initialize AudioRecorderManager with AudioDeviceManager integration
         audioRecorderManager = AudioRecorderManager.initialize(
@@ -936,7 +970,7 @@ class ExpoAudioStreamModule : Module(), EventSender {
                         
                         // Notify JS about the disconnection
                         sendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
-                            "reason" to "deviceDisconnected",
+                            "type" to "deviceDisconnected",
                             "deviceId" to deviceId
                         ))
                     } catch (e: Exception) {
@@ -946,6 +980,26 @@ class ExpoAudioStreamModule : Module(), EventSender {
             }
         }
         
+        // Set up connection callback
+        audioDeviceManager.onDeviceConnected = { deviceId ->
+            LogUtils.d(CLASS_NAME, "📱 Device connected: $deviceId")
+            // Notify JS about the connection
+            sendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
+                "type" to "deviceConnected",
+                "deviceId" to deviceId
+            ))
+        }
+        
+        // Set up disconnection callback
+        audioDeviceManager.onDeviceDisconnected = { deviceId ->
+            LogUtils.d(CLASS_NAME, "📱 Device disconnected: $deviceId")
+            // Notify JS about the disconnection
+            sendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
+                "type" to "deviceDisconnected",
+                "deviceId" to deviceId
+            ))
+        }
+        
         audioProcessor = AudioProcessor(filesDir)
     }
     

package/app.plugin.js

@@ -1 +1,3 @@
-module.exports = require('./plugin/build')
+// Plugin for app.json usage (regular Node.js context)
+const plugin = require('./plugin/build/index.js')
+module.exports = plugin.default || plugin