@siteed/expo-audio-stream 1.1.16 → 1.2.0

package/ios/ExpoAudioStreamModule.swift

@@ -6,12 +6,14 @@ let audioAnalysisEvent: String = "AudioAnalysis"
 
 public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
     private var streamManager = AudioStreamManager()
-    
+    private let notificationCenter = UNUserNotificationCenter.current()
+    private let notificationIdentifier = "audio_recording_notification"
+        
     public func definition() -> ModuleDefinition {
         Name("ExpoAudioStream")
         
         // Defines event names that the module can send to JavaScript.
-        Events([audioDataEvent, audioAnalysisEvent])
+        Events([audioDataEvent, audioAnalysisEvent, "recordingStateChanged", "notificationStateChanged"])
         
         OnCreate {
             print("Setting streamManager delegate")
@@ -130,44 +132,30 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                     return
                 }
                 
-                // Extract settings from provided options, using default values if necessary
-                let sampleRate = options["sampleRate"] as? Double ?? 16000.0 // it fails if not 48000, why?
-                let numberOfChannels = options["channelConfig"] as? Int ?? 1 // Mono channel configuration
-                let bitDepth = options["audioFormat"] as? Int ?? 16 // 16bits
-                let interval = options["interval"] as? Int ?? 1000
-                
-                // Extract processing options with default values
-                let enableProcessing = options["enableProcessing"] as? Bool ?? false
-                let pointsPerSecond = options["pointsPerSecond"] as? Int ?? 20
-                let algorithm = options["algorithm"] as? String ?? "rms"
-                let featureOptions = options["featureOptions"] as? [String: Bool] ?? [:]
-                let maxRecentDataDuration = options["maxRecentDataDuration"] as? Double ?? 10.0
+                let settings = RecordingSettings.fromDictionary(options)
                 
-                // Create recording settings
-                let settings = RecordingSettings(
-                    sampleRate: sampleRate,
-                    desiredSampleRate: sampleRate,
-                    numberOfChannels: numberOfChannels,
-                    bitDepth: bitDepth,
-                    maxRecentDataDuration: enableProcessing ? maxRecentDataDuration : nil,
-                    enableProcessing: enableProcessing,
-                    pointsPerSecond: enableProcessing ? pointsPerSecond : nil,
-                    algorithm: enableProcessing ? algorithm : nil,
-                    featureOptions: enableProcessing ? featureOptions : nil
-                )
-                
-                if let result = self.streamManager.startRecording(settings: settings, intervalMilliseconds: interval) {
-                    let resultDict: [String: Any] = [
-                        "fileUri": result.fileUri,
-                        "channels": result.channels,
-                        "bitDepth": result.bitDepth,
-                        "sampleRate": result.sampleRate,
-                        "mimeType": result.mimeType,
-                    ]
-                    promise.resolve(resultDict)
-                } else {
-                    promise.reject("ERROR", "Failed to start recording.")
+                // Initialize notification if enabled
+                if settings.showNotification {
+                    Task {
+                        let notificationGranted = await self.requestNotificationPermissions()
+                        if !notificationGranted {
+                            Logger.debug("Notification permissions not granted")
+                        }
+                    }
                 }
+                
+                if let result = self.streamManager.startRecording(settings: settings, intervalMilliseconds: settings.interval ?? 1000) {
+                      let resultDict: [String: Any] = [
+                          "fileUri": result.fileUri,
+                          "channels": result.channels,
+                          "bitDepth": result.bitDepth,
+                          "sampleRate": result.sampleRate,
+                          "mimeType": result.mimeType,
+                      ]
+                      promise.resolve(resultDict)
+                  } else {
+                      promise.reject("ERROR", "Failed to start recording.")
+                  }
             }
         }
         
@@ -242,6 +230,16 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             }
         }
         
+        AsyncFunction("requestNotificationPermissionsAsync") { (promise: Promise) in
+            Task {
+                let granted = await requestNotificationPermissions()
+                promise.resolve([
+                    "granted": granted,
+                    "status": granted ? "granted" : "denied"
+                ])
+            }
+        }
+        
         /// Gets the current audio recording permissions.
         ///
         /// - Parameters:
@@ -262,6 +260,26 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         }
     }
     
+    func audioStreamManager(_ manager: AudioStreamManager, didPauseRecording pauseTime: Date) {
+        sendEvent("recordingStateChanged", [
+            "state": "paused",
+            "timestamp": pauseTime.timeIntervalSince1970 * 1000
+        ])
+    }
+    
+    func audioStreamManager(_ manager: AudioStreamManager, didResumeRecording resumeTime: Date) {
+        sendEvent("recordingStateChanged", [
+            "state": "recording",
+            "timestamp": resumeTime.timeIntervalSince1970 * 1000
+        ])
+    }
+    
+    func audioStreamManager(_ manager: AudioStreamManager, didUpdateNotificationState isPaused: Bool) {
+        sendEvent("notificationStateChanged", [
+            "isPaused": isPaused
+        ])
+    }
+    
     /// Handles the reception of audio data from the AudioStreamManager.
     ///
     /// - Parameters:
@@ -301,6 +319,16 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         sendEvent(audioDataEvent, eventBody)
     }
     
+    private func requestNotificationPermissions() async -> Bool {
+        do {
+            let options: UNAuthorizationOptions = [.alert, .sound]
+            return try await notificationCenter.requestAuthorization(options: options)
+        } catch {
+            Logger.debug("Failed to request notification permissions: \(error)")
+            return false
+        }
+    }
+    
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveProcessingResult result: AudioAnalysisData?) {
         // Handle the processed audio data
         // Emit the processing result event to JavaScript

package/ios/NotificationExtension.swift

@@ -0,0 +1,15 @@
+//
+//  NotificationExtension.swift
+//  Pods
+//
+//  Created by Arthur Breton on 27/10/2024.
+//
+
+
+import Foundation
+
+extension Notification.Name {
+    static let pauseRecording = Notification.Name("PAUSE_RECORDING")
+    static let resumeRecording = Notification.Name("RESUME_RECORDING")
+    static let notificationActionTriggered = Notification.Name("notificationActionTriggered")
+}

package/ios/RecordingSettings.swift

@@ -1,13 +1,91 @@
 // RecordingSettings.swift
 
+struct NotificationAction {
+    var title: String
+    var identifier: String
+}
+
+struct IOSNotificationConfig {
+    var categoryIdentifier: String?
+    var actions: [NotificationAction]?
+}
+
+struct NotificationConfig {
+    var title: String?
+    var text: String?
+    var icon: String?
+    var ios: IOSNotificationConfig?
+}
+
 struct RecordingSettings {
+    // Core recording settings
     var sampleRate: Double
     var desiredSampleRate: Double
     var numberOfChannels: Int = 1
     var bitDepth: Int = 16
-    var maxRecentDataDuration: Double? = 10.0 // Default to 10 seconds
-    var enableProcessing: Bool = false // Flag to enable/disable processing
-    var pointsPerSecond: Int? = 1000 // Default value
-    var algorithm: String? = "rms" // Default algorithm
-    var featureOptions: [String: Bool]? = ["rms": true, "zcr": true] // Default features
+    var interval: Int?
+    
+    // Feature flags
+    var keepAwake: Bool = false
+    var showNotification: Bool = false
+    var enableProcessing: Bool = false
+    
+    // Analysis settings
+    var pointsPerSecond: Int? = 1000
+    var algorithm: String? = "rms"
+    var featureOptions: [String: Bool]? = ["rms": true, "zcr": true]
+    
+    // Notification configuration
+    var notification: NotificationConfig?
+    
+    static func fromDictionary(_ dict: [String: Any]) -> RecordingSettings {
+        var settings = RecordingSettings(
+            sampleRate: dict["sampleRate"] as? Double ?? 44100.0,
+            desiredSampleRate: dict["desiredSampleRate"] as? Double ?? 44100.0
+        )
+        
+        // Parse core settings
+        settings.numberOfChannels = dict["channels"] as? Int ?? 1
+        settings.bitDepth = dict["bitDepth"] as? Int ?? 16
+        settings.interval = dict["interval"] as? Int
+        
+        // Parse feature flags
+        settings.keepAwake = dict["keepAwake"] as? Bool ?? false
+        settings.showNotification = dict["showNotification"] as? Bool ?? false
+        settings.enableProcessing = dict["enableProcessing"] as? Bool ?? false
+        
+        // Parse analysis settings
+        settings.pointsPerSecond = dict["pointsPerSecond"] as? Int
+        settings.algorithm = dict["algorithm"] as? String
+        settings.featureOptions = dict["features"] as? [String: Bool]
+        
+        // Parse notification config
+        if let notificationDict = dict["notification"] as? [String: Any] {
+            var notificationConfig = NotificationConfig()
+            notificationConfig.title = notificationDict["title"] as? String
+            notificationConfig.text = notificationDict["text"] as? String
+            notificationConfig.icon = notificationDict["icon"] as? String
+            
+            // Parse iOS-specific notification config
+            if let iosDict = notificationDict["ios"] as? [String: Any] {
+                var iosConfig = IOSNotificationConfig()
+                iosConfig.categoryIdentifier = iosDict["categoryIdentifier"] as? String
+                
+                if let actionsArray = iosDict["actions"] as? [[String: Any]] {
+                    iosConfig.actions = actionsArray.map { actionDict in
+                        NotificationAction(
+                            title: actionDict["title"] as? String ?? "",
+                            identifier: actionDict["identifier"] as? String ?? ""
+                        )
+                    }
+                }
+                
+                notificationConfig.ios = iosConfig
+            }
+            
+            settings.notification = notificationConfig
+        }
+        
+        return settings
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "1.1.16",
+  "version": "1.2.0",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",

package/plugin/build/index.d.ts

@@ -1,5 +1,3 @@
 import { ConfigPlugin } from '@expo/config-plugins';
-declare const withRecordingPermission: ConfigPlugin<{
-    microphonePermission: string;
-}>;
+declare const withRecordingPermission: ConfigPlugin;
 export default withRecordingPermission;

package/plugin/build/index.js

@@ -2,25 +2,118 @@
 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 withRecordingPermission = (config, existingPerms) => {
-    if (!existingPerms) {
-        console.warn('No previous permissions provided');
-    }
+const NOTIFICATION_USAGE = 'Show recording notifications and controls';
+const withRecordingPermission = (config) => {
+    // iOS Configuration
     config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
-        config.modResults['NSMicrophoneUsageDescription'] = MICROPHONE_USAGE;
-        // Add audio to UIBackgroundModes to allow background audio recording
+        // Existing microphone permission
+        config.modResults['NSMicrophoneUsageDescription'] =
+            config.modResults['NSMicrophoneUsageDescription'] ||
+                MICROPHONE_USAGE;
+        // Add notification permissions
+        // This is the correct key for iOS notifications
+        config.modResults['NSUserNotificationsUsageDescription'] =
+            NOTIFICATION_USAGE;
+        // Add notification style
+        config.modResults['NSUserNotificationAlertStyle'] = 'alert';
+        // Background modes
         const existingBackgroundModes = config.modResults.UIBackgroundModes || [];
         if (!existingBackgroundModes.includes('audio')) {
             existingBackgroundModes.push('audio');
         }
+        if (!existingBackgroundModes.includes('remote-notification')) {
+            existingBackgroundModes.push('remote-notification');
+        }
         config.modResults.UIBackgroundModes = existingBackgroundModes;
+        // Required capabilities for notifications
+        if (!config.modResults.UIRequiredDeviceCapabilities) {
+            config.modResults.UIRequiredDeviceCapabilities = [];
+        }
+        const capabilities = config.modResults
+            .UIRequiredDeviceCapabilities;
+        if (!capabilities.includes('notification')) {
+            capabilities.push('notification');
+        }
         return config;
     });
+    // Android Configuration
     config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
-        const mainApplication = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
-        config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(mainApplication, 'android.permission.RECORD_AUDIO', MICROPHONE_USAGE);
-        // Add FOREGROUND_SERVICE permission for handling background recording
-        config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(mainApplication, 'android.permission.FOREGROUND_SERVICE', 'This apps needs access to the foreground service to record audio in the background');
+        const androidManifest = config.modResults;
+        if (!androidManifest.manifest) {
+            console.warn('withRecordingPermission: androidManifest.manifest is null');
+            return config;
+        }
+        // Add xmlns:android attribute to manifest
+        androidManifest.manifest.$ = {
+            ...androidManifest.manifest.$,
+            'xmlns:android': 'http://schemas.android.com/apk/res/android',
+        };
+        // Ensure permissions array exists
+        if (!androidManifest.manifest['uses-permission']) {
+            androidManifest.manifest['uses-permission'] = [];
+        }
+        const { addPermission } = config_plugins_1.AndroidConfig.Permissions;
+        // Required permissions
+        const permissionsToAdd = [
+            'android.permission.RECORD_AUDIO',
+            'android.permission.FOREGROUND_SERVICE',
+            'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+            'android.permission.WAKE_LOCK',
+            'android.permission.POST_NOTIFICATIONS',
+        ];
+        // Add each permission
+        permissionsToAdd.forEach((permission) => {
+            addPermission(androidManifest, permission);
+        });
+        // Get the main application node
+        const mainApplication = androidManifest.manifest.application?.[0];
+        if (mainApplication) {
+            // 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);
+            }
+            // 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);
+            }
+        }
         return config;
     });
     return config;

package/plugin/src/index.ts

@@ -1,48 +1,151 @@
 import {
-    AndroidConfig,
     ConfigPlugin,
     withAndroidManifest,
     withInfoPlist,
+    AndroidConfig,
 } from '@expo/config-plugins'
+import { ExpoConfig } from '@expo/config-types'
 
 const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone'
+const NOTIFICATION_USAGE = 'Show recording notifications and controls'
 
-const withRecordingPermission: ConfigPlugin<{
-    microphonePermission: string
-}> = (config, existingPerms) => {
-    if (!existingPerms) {
-        console.warn('No previous permissions provided')
-    }
+const withRecordingPermission: ConfigPlugin = (config: ExpoConfig) => {
+    // iOS Configuration
     config = withInfoPlist(config, (config) => {
-        config.modResults['NSMicrophoneUsageDescription'] = MICROPHONE_USAGE
+        // Existing microphone permission
+        config.modResults['NSMicrophoneUsageDescription'] =
+            config.modResults['NSMicrophoneUsageDescription'] ||
+            MICROPHONE_USAGE
+
+        // Add notification permissions
+        // This is the correct key for iOS notifications
+        config.modResults['NSUserNotificationsUsageDescription'] =
+            NOTIFICATION_USAGE
 
-        // Add audio to UIBackgroundModes to allow background audio recording
+        // Add notification style
+        config.modResults['NSUserNotificationAlertStyle'] = 'alert'
+
+        // Background modes
         const existingBackgroundModes =
             config.modResults.UIBackgroundModes || []
         if (!existingBackgroundModes.includes('audio')) {
             existingBackgroundModes.push('audio')
         }
+        if (!existingBackgroundModes.includes('remote-notification')) {
+            existingBackgroundModes.push('remote-notification')
+        }
         config.modResults.UIBackgroundModes = existingBackgroundModes
 
+        // Required capabilities for notifications
+        if (!config.modResults.UIRequiredDeviceCapabilities) {
+            config.modResults.UIRequiredDeviceCapabilities = []
+        }
+        const capabilities = config.modResults
+            .UIRequiredDeviceCapabilities as string[]
+        if (!capabilities.includes('notification')) {
+            capabilities.push('notification')
+        }
+
         return config
     })
 
+    // Android Configuration
     config = withAndroidManifest(config, (config) => {
-        const mainApplication =
-            AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults)
+        const androidManifest = config.modResults
+        if (!androidManifest.manifest) {
+            console.warn(
+                'withRecordingPermission: androidManifest.manifest is null'
+            )
+            return config
+        }
 
-        AndroidConfig.Manifest.addMetaDataItemToMainApplication(
-            mainApplication,
-            'android.permission.RECORD_AUDIO',
-            MICROPHONE_USAGE
-        )
+        // Add xmlns:android attribute to manifest
+        androidManifest.manifest.$ = {
+            ...androidManifest.manifest.$,
+            'xmlns:android': 'http://schemas.android.com/apk/res/android',
+        }
 
-        // Add FOREGROUND_SERVICE permission for handling background recording
-        AndroidConfig.Manifest.addMetaDataItemToMainApplication(
-            mainApplication,
+        // Ensure permissions array exists
+        if (!androidManifest.manifest['uses-permission']) {
+            androidManifest.manifest['uses-permission'] = []
+        }
+
+        const { addPermission } = AndroidConfig.Permissions
+
+        // Required permissions
+        const permissionsToAdd = [
+            'android.permission.RECORD_AUDIO',
             'android.permission.FOREGROUND_SERVICE',
-            'This apps needs access to the foreground service to record audio in the background'
-        )
+            'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+            'android.permission.WAKE_LOCK',
+            'android.permission.POST_NOTIFICATIONS',
+        ]
+
+        // Add each permission
+        permissionsToAdd.forEach((permission) => {
+            addPermission(androidManifest, permission)
+        })
+
+        // Get the main application node
+        const mainApplication = androidManifest.manifest.application?.[0]
+        if (mainApplication) {
+            // Add RecordingActionReceiver
+            if (!mainApplication.receiver) {
+                mainApplication.receiver = []
+            }
+
+            const receiverConfig = {
+                $: {
+                    'android:name': '.RecordingActionReceiver',
+                    'android:exported': 'false' as const,
+                },
+                'intent-filter': [
+                    {
+                        action: [
+                            { $: { 'android:name': 'PAUSE_RECORDING' } },
+                            { $: { 'android:name': 'RESUME_RECORDING' } },
+                            { $: { 'android:name': 'STOP_RECORDING' } },
+                        ],
+                    },
+                ],
+            }
+
+            const receiverIndex = mainApplication.receiver.findIndex(
+                (receiver: any) =>
+                    receiver.$?.['android:name'] === '.RecordingActionReceiver'
+            )
+
+            if (receiverIndex >= 0) {
+                mainApplication.receiver[receiverIndex] = receiverConfig
+            } else {
+                mainApplication.receiver.push(receiverConfig)
+            }
+
+            // Add AudioRecordingService
+            if (!mainApplication.service) {
+                mainApplication.service = []
+            }
+
+            const serviceConfig = {
+                $: {
+                    'android:name': '.AudioRecordingService',
+                    'android:enabled': 'true' as const,
+                    'android:exported': 'false' as const,
+                    'android:foregroundServiceType': 'microphone',
+                },
+            }
+
+            const serviceIndex = mainApplication.service.findIndex(
+                (service: any) =>
+                    service.$?.['android:name'] === '.AudioRecordingService'
+            )
+
+            if (serviceIndex >= 0) {
+                mainApplication.service[serviceIndex] = serviceConfig
+            } else {
+                mainApplication.service.push(serviceConfig)
+            }
+        }
 
         return config
     })

package/publish.sh

@@ -3,9 +3,39 @@ set -e
 
 echo "Starting publication process..."
 
-# Bump version
-echo "Bumping version..."
-yarn version patch
+# Get current version from package.json
+current_version=$(node -p "require('./package.json').version")
+echo "Current version: $current_version"
+
+# Ask user for version bump type
+echo "Please select version bump type:"
+echo "1) patch (x.x.X)"
+echo "2) minor (x.X.0)"
+echo "3) major (X.0.0)"
+echo "4) manual"
+read -p "Enter choice (1-4): " choice
+
+case $choice in
+    1)
+        yarn version patch
+        ;;
+    2)
+        yarn version minor
+        ;;
+    3)
+        yarn version major
+        ;;
+    4)
+        read -p "Enter new version (current: $current_version): " new_version
+        yarn version $new_version
+        ;;
+    *)
+        echo "Invalid choice. Exiting."
+        exit 1
+        ;;
+esac
+
+# Get new version after bump
 version=$(node -p "require('./package.json').version")
 echo "New version: $version"
 
@@ -13,6 +43,9 @@ echo "New version: $version"
 echo "Generating updated documentation..."
 yarn docgen
 
+echo "Waiting while docs are generated..."
+sleep 3000
+
 # Prepare and publish package
 echo "Preparing and publishing package..."
 yarn clean && yarn prepare && yarn npm publish