@siteed/expo-audio-studio 2.12.3 → 2.13.0

package/ios/ExpoAudioStreamModule.swift

@@ -18,7 +18,7 @@ private let audioDeviceTypeWiredHeadphones = "wired_headphones"
 private let audioDeviceTypeSpeaker = "speaker"
 private let audioDeviceTypeUnknown = "unknown"
 
-public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
+public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate, AudioDeviceManagerDelegate {
     private var streamManager = AudioStreamManager()
     private let notificationCenter = UNUserNotificationCenter.current()
     private let notificationIdentifier = "audio_recording_notification"
@@ -41,11 +41,30 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         OnCreate {
             Logger.debug("ExpoAudioStreamModule", "Module created, setting delegate and starting device monitoring.")
             streamManager.delegate = self
+            // Set up device manager delegate to emit device change events
+            deviceManager.delegate = self
+            
+            // Listen for device connection notifications (minimal addition)
+            NotificationCenter.default.addObserver(
+                forName: NSNotification.Name("DeviceConnected"),
+                object: nil,
+                queue: .main
+            ) { [weak self] notification in
+                if let deviceId = notification.userInfo?["deviceId"] as? String {
+                    Logger.debug("ExpoAudioStreamModule", "Device connected: \(deviceId)")
+                    self?.sendEvent(deviceChangedEvent, [
+                        "type": "deviceConnected",
+                        "deviceId": deviceId
+                    ])
+                }
+            }
         }
         
         OnDestroy {
             Logger.debug("ExpoAudioStreamModule", "Module destroyed, stopping device monitoring.")
             _ = streamManager.stopRecording()
+            // Clear device manager delegate
+            deviceManager.delegate = nil
         }
         
         /// Extracts audio analysis data from an audio file.
@@ -980,4 +999,17 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         Logger.error("ExpoAudioStreamModule", "Delegate: didFailWithError: \(error)")
         sendEvent(errorEvent, [ "message": error ])
     }
+    
+    // MARK: - AudioDeviceManagerDelegate
+    
+    /// Handles device disconnection events from the AudioDeviceManager
+    func audioDeviceManager(_ manager: AudioDeviceManager, didDetectDisconnectionOfDevice deviceId: String) {
+        Logger.debug("ExpoAudioStreamModule", "Device disconnected: \(deviceId)")
+        
+        // Emit device change event to match Android implementation
+        sendEvent(deviceChangedEvent, [
+            "type": "deviceDisconnected",
+            "deviceId": deviceId
+        ])
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/expo-audio-studio",
-    "version": "2.12.3",
+    "version": "2.13.0",
     "description": "Comprehensive audio processing library for React Native and Expo with recording, analysis, visualization, and streaming capabilities across iOS, Android, and web",
     "license": "MIT",
     "type": "commonjs",
@@ -74,11 +74,12 @@
         "build:cjs": "tsc -p tsconfig.cjs.json",
         "build:esm": "tsc -p tsconfig.esm.json",
         "build:types": "tsc -p tsconfig.types.json",
-        "build:plugin": "tsc --build plugin/tsconfig.json",
+        "build:plugin": "tsc --project plugin/tsconfig.json && cp plugin/build/index.js plugin/build/index.cjs",
         "build:plugin:dev": "expo-module build plugin",
         "build:dev": "expo-module build",
         "clean": "expo-module clean && rimraf build plugin/build",
         "lint": "expo-module lint",
+        "lint:fix": "expo-module lint --fix",
         "test": "expo-module test",
         "test:android": "yarn test:android:unit && yarn test:android:instrumented",
         "test:android:unit": "cd ../../apps/playground/android && ./gradlew :siteed-expo-audio-studio:test",
@@ -100,6 +101,9 @@
         "agent:test:integration": "yarn test:android:instrumented",
         "agent:compilation:check": "yarn typecheck && yarn build"
     },
+    "dependencies": {
+        "expo-modules-core": "~2.3.13"
+    },
     "devDependencies": {
         "@expo/config-plugins": "~10.0.0",
         "@expo/npm-proofread": "^1.0.1",
@@ -122,7 +126,8 @@
         "expo-module-scripts": "^4.1.7",
         "jest": "^29.7.0",
         "prettier": "^3.2.5",
-        "react-native": "0.79.2",
+        "react": "19.0.0",
+        "react-native": "0.79.3",
         "rimraf": "^6.0.1",
         "size-limit": "^11.1.4",
         "ts-node": "^10.9.2",
@@ -138,8 +143,5 @@
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org"
-    },
-    "dependencies": {
-        "expo-modules-core": "~2.3.13"
     }
 }

package/plugin/build/index.cjs

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone';
+const NOTIFICATION_USAGE = 'Show recording notifications and controls';
+const LOG_PREFIX = '[@siteed/expo-audio-studio]';
+function debugLog(message, ...args) {
+    if (process.env.EXPO_DEBUG) {
+        console.log(`${LOG_PREFIX} ${message}`, ...args);
+    }
+}
+const withRecordingPermission = (config, props) => {
+    const options = {
+        enablePhoneStateHandling: true, // Default to true for backward compatibility
+        enableNotifications: true,
+        enableBackgroundAudio: true,
+        enableDeviceDetection: true, // Default to true for backward compatibility
+        iosBackgroundModes: {
+            useVoIP: false,
+            useAudio: false,
+            useProcessing: false,
+            useLocation: false,
+            useExternalAccessory: false,
+        },
+        iosConfig: {
+            microphoneUsageDescription: MICROPHONE_USAGE,
+            notificationUsageDescription: NOTIFICATION_USAGE,
+        },
+        ...(props || {}),
+    };
+    const { enablePhoneStateHandling, enableNotifications, enableBackgroundAudio, enableDeviceDetection, } = options;
+    debugLog('📱 Configuring Recording Permissions Plugin...', options);
+    // iOS Configuration
+    config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        // Always set the microphone usage description from options first
+        config.modResults['NSMicrophoneUsageDescription'] =
+            options.iosConfig?.microphoneUsageDescription ||
+                config.modResults['NSMicrophoneUsageDescription'] ||
+                MICROPHONE_USAGE;
+        if (enableNotifications) {
+            config.modResults['NSUserNotificationsUsageDescription'] =
+                options.iosConfig?.notificationUsageDescription ||
+                    config.modResults['NSUserNotificationsUsageDescription'] ||
+                    NOTIFICATION_USAGE;
+            config.modResults['NSUserNotificationAlertStyle'] = 'alert';
+        }
+        const existingBackgroundModes = config.modResults.UIBackgroundModes || [];
+        // If background audio is enabled with useAudio, add the audio background mode
+        if (options.iosBackgroundModes?.useAudio === true &&
+            enableBackgroundAudio === true &&
+            !existingBackgroundModes.includes('audio')) {
+            // Add 'audio' background mode - REQUIRED for background recording
+            existingBackgroundModes.push('audio');
+            debugLog('✅ Added audio background mode for iOS background recording');
+            // Also ensure processing mode is recommended
+            if (options.iosBackgroundModes?.useProcessing !== true) {
+                console.warn(`${LOG_PREFIX} Warning: Background audio recording works best with both 'audio' and 'processing' background modes. Consider enabling 'useProcessing' in iosBackgroundModes.`);
+            }
+        }
+        if (options.iosBackgroundModes?.useVoIP === true &&
+            enablePhoneStateHandling === true) {
+            if (!existingBackgroundModes.includes('voip')) {
+                existingBackgroundModes.push('voip');
+            }
+            const existingCapabilities = (config.modResults
+                .UIRequiredDeviceCapabilities || []);
+            if (!existingCapabilities.includes('telephony')) {
+                existingCapabilities.push('telephony');
+            }
+            config.modResults.UIRequiredDeviceCapabilities =
+                existingCapabilities;
+        }
+        // Add additional background modes only if explicitly set to true
+        if (options.iosBackgroundModes?.useProcessing === true) {
+            if (!existingBackgroundModes.includes('processing')) {
+                existingBackgroundModes.push('processing');
+            }
+            // Add processing info if enabled
+            // Note: We keep the 'audiostream' namespace for native modules to maintain compatibility
+            config.modResults.BGTaskSchedulerPermittedIdentifiers = [
+                'com.siteed.audiostream.processing',
+            ];
+        }
+        if (options.iosBackgroundModes?.useLocation === true) {
+            if (!existingBackgroundModes.includes('location')) {
+                existingBackgroundModes.push('location');
+            }
+        }
+        if (options.iosBackgroundModes?.useExternalAccessory === true) {
+            if (!existingBackgroundModes.includes('external-accessory')) {
+                existingBackgroundModes.push('external-accessory');
+            }
+        }
+        // Configure background processing info if enabled
+        if (options.iosConfig?.backgroundProcessingTitle) {
+            config.modResults.BGProcessingTaskTitle =
+                options.iosConfig.backgroundProcessingTitle;
+        }
+        // Configure audio session behavior
+        if (options.iosConfig?.allowBackgroundAudioControls) {
+            config.modResults.UIBackgroundModes = [
+                ...existingBackgroundModes,
+                'remote-notification',
+            ];
+            config.modResults.MPNowPlayingInfoPropertyPlaybackRate = true;
+        }
+        config.modResults.UIBackgroundModes = existingBackgroundModes;
+        return config;
+    });
+    // Android Configuration
+    config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const basePermissions = [
+            'android.permission.RECORD_AUDIO',
+            'android.permission.WAKE_LOCK',
+        ];
+        const optionalPermissions = [
+            enableNotifications && 'android.permission.POST_NOTIFICATIONS',
+            enablePhoneStateHandling && 'android.permission.READ_PHONE_STATE', // Only add if enabled
+            enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE',
+            enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+            // Device detection permissions (only if enabled)
+            enableDeviceDetection && 'android.permission.BLUETOOTH',
+            enableDeviceDetection && 'android.permission.BLUETOOTH_CONNECT',
+            enableDeviceDetection && 'android.permission.USB_PERMISSION',
+        ].filter(Boolean);
+        const permissionsToAdd = [...basePermissions, ...optionalPermissions];
+        debugLog('📋 Existing Android permissions:', config.modResults.manifest['uses-permission']?.map((p) => p.$?.['android:name']) || []);
+        debugLog('➕ Adding Android permissions:', permissionsToAdd);
+        // Add each permission only if it doesn't exist
+        permissionsToAdd.forEach((permission) => {
+            config_plugins_1.AndroidConfig.Permissions.addPermission(config.modResults, permission);
+        });
+        // Get the main application node
+        const mainApplication = config.modResults.manifest.application?.[0];
+        if (mainApplication) {
+            debugLog('📱 Configuring Android application components...');
+            // Add RecordingActionReceiver
+            if (!mainApplication.receiver) {
+                mainApplication.receiver = [];
+            }
+            const receiverConfig = {
+                $: {
+                    'android:name': '.RecordingActionReceiver',
+                    'android:exported': 'false',
+                },
+                'intent-filter': [
+                    {
+                        action: [
+                            { $: { 'android:name': 'PAUSE_RECORDING' } },
+                            { $: { 'android:name': 'RESUME_RECORDING' } },
+                            { $: { 'android:name': 'STOP_RECORDING' } },
+                        ],
+                    },
+                ],
+            };
+            const receiverIndex = mainApplication.receiver.findIndex((receiver) => receiver.$?.['android:name'] === '.RecordingActionReceiver');
+            if (receiverIndex >= 0) {
+                mainApplication.receiver[receiverIndex] = receiverConfig;
+            }
+            else {
+                mainApplication.receiver.push(receiverConfig);
+            }
+            debugLog('✅ RecordingActionReceiver configured');
+            // Add AudioRecordingService
+            if (!mainApplication.service) {
+                mainApplication.service = [];
+            }
+            const serviceConfig = {
+                $: {
+                    'android:name': '.AudioRecordingService',
+                    'android:enabled': 'true',
+                    'android:exported': 'false',
+                    'android:foregroundServiceType': 'microphone',
+                },
+            };
+            const serviceIndex = mainApplication.service.findIndex((service) => service.$?.['android:name'] === '.AudioRecordingService');
+            if (serviceIndex >= 0) {
+                mainApplication.service[serviceIndex] = serviceConfig;
+            }
+            else {
+                mainApplication.service.push(serviceConfig);
+            }
+            debugLog('✅ AudioRecordingService configured');
+        }
+        else {
+            console.error(`${LOG_PREFIX} ❌ Main application node not found in Android Manifest`);
+        }
+        return config;
+    });
+    debugLog('✨ Recording Permissions Plugin configuration completed');
+    return config;
+};
+// Export as default
+exports.default = withRecordingPermission;

package/plugin/build/index.d.cts

@@ -3,6 +3,7 @@ interface AudioStreamPluginOptions {
     enablePhoneStateHandling?: boolean;
     enableNotifications?: boolean;
     enableBackgroundAudio?: boolean;
+    enableDeviceDetection?: boolean;
     iosBackgroundModes?: {
         useVoIP?: boolean;
         useAudio?: boolean;

package/plugin/build/index.js

@@ -14,6 +14,7 @@ const withRecordingPermission = (config, props) => {
         enablePhoneStateHandling: true, // Default to true for backward compatibility
         enableNotifications: true,
         enableBackgroundAudio: true,
+        enableDeviceDetection: true, // Default to true for backward compatibility
         iosBackgroundModes: {
             useVoIP: false,
             useAudio: false,
@@ -27,7 +28,7 @@ const withRecordingPermission = (config, props) => {
         },
         ...(props || {}),
     };
-    const { enablePhoneStateHandling, enableNotifications, enableBackgroundAudio, } = options;
+    const { enablePhoneStateHandling, enableNotifications, enableBackgroundAudio, enableDeviceDetection, } = options;
     debugLog('📱 Configuring Recording Permissions Plugin...', options);
     // iOS Configuration
     config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
@@ -117,17 +118,17 @@ const withRecordingPermission = (config, props) => {
             enablePhoneStateHandling && 'android.permission.READ_PHONE_STATE', // Only add if enabled
             enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE',
             enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+            // Device detection permissions (only if enabled)
+            enableDeviceDetection && 'android.permission.BLUETOOTH',
+            enableDeviceDetection && 'android.permission.BLUETOOTH_CONNECT',
+            enableDeviceDetection && 'android.permission.USB_PERMISSION',
         ].filter(Boolean);
         const permissionsToAdd = [...basePermissions, ...optionalPermissions];
         debugLog('📋 Existing Android permissions:', config.modResults.manifest['uses-permission']?.map((p) => p.$?.['android:name']) || []);
         debugLog('➕ Adding Android permissions:', permissionsToAdd);
-        const { addPermission } = config_plugins_1.AndroidConfig.Permissions;
         // Add each permission only if it doesn't exist
         permissionsToAdd.forEach((permission) => {
-            const existingPermission = config.modResults.manifest['uses-permission']?.find((p) => p.$?.['android:name'] === permission);
-            if (!existingPermission) {
-                addPermission(config.modResults, permission);
-            }
+            config_plugins_1.AndroidConfig.Permissions.addPermission(config.modResults, permission);
         });
         // Get the main application node
         const mainApplication = config.modResults.manifest.application?.[0];

package/plugin/src/index.ts

@@ -20,6 +20,7 @@ interface AudioStreamPluginOptions {
     enablePhoneStateHandling?: boolean // Controls READ_PHONE_STATE permission
     enableNotifications?: boolean
     enableBackgroundAudio?: boolean
+    enableDeviceDetection?: boolean // Controls Bluetooth and USB permissions for device change detection
     iosBackgroundModes?: {
         useVoIP?: boolean
         useAudio?: boolean
@@ -43,6 +44,7 @@ const withRecordingPermission: ConfigPlugin<AudioStreamPluginOptions> = (
         enablePhoneStateHandling: true, // Default to true for backward compatibility
         enableNotifications: true,
         enableBackgroundAudio: true,
+        enableDeviceDetection: true, // Default to true for backward compatibility
         iosBackgroundModes: {
             useVoIP: false,
             useAudio: false,
@@ -61,6 +63,7 @@ const withRecordingPermission: ConfigPlugin<AudioStreamPluginOptions> = (
         enablePhoneStateHandling,
         enableNotifications,
         enableBackgroundAudio,
+        enableDeviceDetection,
     } = options
 
     debugLog('📱 Configuring Recording Permissions Plugin...', options)
@@ -175,6 +178,10 @@ const withRecordingPermission: ConfigPlugin<AudioStreamPluginOptions> = (
             enablePhoneStateHandling && 'android.permission.READ_PHONE_STATE', // Only add if enabled
             enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE',
             enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+            // Device detection permissions (only if enabled)
+            enableDeviceDetection && 'android.permission.BLUETOOTH',
+            enableDeviceDetection && 'android.permission.BLUETOOTH_CONNECT',
+            enableDeviceDetection && 'android.permission.USB_PERMISSION',
         ].filter(Boolean) as string[]
 
         const permissionsToAdd = [...basePermissions, ...optionalPermissions]
@@ -188,16 +195,9 @@ const withRecordingPermission: ConfigPlugin<AudioStreamPluginOptions> = (
 
         debugLog('➕ Adding Android permissions:', permissionsToAdd)
 
-        const { addPermission } = AndroidConfig.Permissions
-
         // Add each permission only if it doesn't exist
         permissionsToAdd.forEach((permission) => {
-            const existingPermission = config.modResults.manifest[
-                'uses-permission'
-            ]?.find((p) => p.$?.['android:name'] === permission)
-            if (!existingPermission) {
-                addPermission(config.modResults, permission)
-            }
+            AndroidConfig.Permissions.addPermission(config.modResults, permission)
         })
 
         // Get the main application node