@siteed/expo-audio-stream 1.1.17 → 1.2.1

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.17",
+  "version": "1.2.1",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",
@@ -38,6 +38,7 @@
   },
   "devDependencies": {
     "@expo/config-plugins": "~8.0.0",
+    "@siteed/publisher": "^0.4.15",
     "@siteed/react-native-logger": "^0.10.0",
     "@size-limit/preset-big-lib": "^11.1.4",
     "@types/jest": "^29.5.12",
@@ -60,6 +61,7 @@
     "prettier": "^3.2.5",
     "react-native": "0.74.5",
     "size-limit": "^11.1.4",
+    "ts-node": "^10.9.2",
     "typedoc": "^0.26.5",
     "typedoc-plugin-markdown": "^4.2.3",
     "typescript": "~5.3.3"

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,10 +43,14 @@ echo "New version: $version"
 echo "Generating updated documentation..."
 yarn docgen
 
+echo "Waiting while docs are generated..."
+sleep 2
+
 # Prepare and publish package
 echo "Preparing and publishing package..."
 yarn clean && yarn prepare && yarn npm publish
 
+sleep 1
 # Publish playground app
 echo "Publishing playground app..."
 cd ../../apps/playground

package/publisher.config.ts

@@ -0,0 +1,39 @@
+import type { ReleaseConfig, DeepPartial } from '@siteed/publisher'
+
+const config: DeepPartial<ReleaseConfig> = {
+    packageManager: 'yarn',
+    changelogFile: 'CHANGELOG.md',
+    conventionalCommits: true,
+    changelogFormat: 'conventional',
+    versionStrategy: 'independent',
+    bumpStrategy: 'prompt',
+    packValidation: {
+        enabled: false,
+        validateFiles: true,
+        validateBuildArtifacts: true,
+    },
+    git: {
+        tagPrefix: '',
+        requireCleanWorkingDirectory: true,
+        requireUpToDate: true,
+        requireUpstreamTracking: true,
+        commit: true,
+        push: true,
+        commitMessage:
+            'chore(expo-audio-stream): release @siteed/expo-audio-stream@${version}',
+        tag: true,
+        allowedBranches: ['main', 'master'],
+        remote: 'origin',
+    },
+    npm: {
+        publish: true,
+        registry: 'https://registry.npmjs.org',
+        tag: 'latest',
+        access: 'public',
+    },
+    hooks: {},
+    updateDependenciesOnRelease: false,
+    dependencyUpdateStrategy: 'none',
+}
+
+export default config

package/src/ExpoAudioStream.types.ts

@@ -64,19 +64,114 @@ export interface StartRecordingResult {
 }
 
 export interface RecordingConfig {
-    sampleRate?: SampleRate // Sample rate for recording
-    channels?: 1 | 2 // 1 or 2 (MONO or STEREO)
-    encoding?: EncodingType // Encoding type for the recording
-    interval?: number // Interval in milliseconds at which to emit recording data
-
-    // Optional parameters for audio processing
-    enableProcessing?: boolean // Boolean to enable/disable audio processing (default is false)
-    pointsPerSecond?: number // Number of data points to extract per second of audio (default is 1000)
-    algorithm?: AmplitudeAlgorithm // Algorithm to use for amplitude computation (default is "rms")
-    features?: AudioFeaturesOptions // Feature options to extract (default is empty)
-
-    onAudioStream?: (_: AudioDataEvent) => Promise<void> // Callback function to handle audio stream
-    onAudioAnalysis?: (_: AudioAnalysisEvent) => Promise<void> // Callback function to handle audio features extraction results
+    // Sample rate for recording (16000, 44100, or 48000 Hz)
+    sampleRate?: SampleRate
+
+    // Number of audio channels (1 for mono, 2 for stereo)
+    channels?: 1 | 2
+
+    // Encoding type for the recording (pcm_32bit, pcm_16bit, pcm_8bit)
+    encoding?: EncodingType
+
+    // Interval in milliseconds at which to emit recording data
+    interval?: number
+
+    // Keep the device awake while recording (default is false)
+    keepAwake?: boolean
+
+    // Show a notification during recording (default is false)
+    showNotification?: boolean
+
+    // Show waveform in the notification (Android only, when showNotification is true)
+    showWaveformInNotification?: boolean
+
+    // Configuration for the notification
+    notification?: NotificationConfig
+
+    // Enable audio processing (default is false)
+    enableProcessing?: boolean
+
+    // Number of data points to extract per second of audio (default is 1000)
+    pointsPerSecond?: number
+
+    // Algorithm to use for amplitude computation (default is "rms")
+    algorithm?: AmplitudeAlgorithm
+
+    // Feature options to extract (default is empty)
+    features?: AudioFeaturesOptions
+
+    // Callback function to handle audio stream
+    onAudioStream?: (_: AudioDataEvent) => Promise<void>
+
+    // Callback function to handle audio features extraction results
+    onAudioAnalysis?: (_: AudioAnalysisEvent) => Promise<void>
+}
+
+export interface NotificationConfig {
+    // Title of the notification
+    title?: string
+
+    // Main text content of the notification
+    text?: string
+
+    // Icon to be displayed in the notification (resource name or URI)
+    icon?: string
+
+    // Android-specific notification configuration
+    android?: {
+        // Unique identifier for the notification channel
+        channelId?: string
+
+        // User-visible name of the notification channel
+        channelName?: string
+
+        // User-visible description of the notification channel
+        channelDescription?: string
+
+        // Unique identifier for this notification
+        notificationId?: number
+
+        // List of actions that can be performed from the notification
+        actions?: NotificationAction[]
+
+        // Configuration for the waveform visualization in the notification
+        waveform?: WaveformConfig
+
+        // Color of the notification LED (if device supports it)
+        lightColor?: string
+
+        // Priority of the notification (affects how it's displayed)
+        priority?: 'min' | 'low' | 'default' | 'high' | 'max'
+
+        // Accent color for the notification (used for the app icon and buttons)
+        accentColor?: string
+    }
+
+    // iOS-specific notification configuration
+    ios?: {
+        // Identifier for the notification category (used for grouping similar notifications)
+        categoryIdentifier?: string
+    }
+}
+
+export interface NotificationAction {
+    // Display title for the action
+    title: string
+
+    // Unique identifier for the action
+    identifier: string
+
+    // Icon to be displayed for the action (Android only)
+    icon?: string
+}
+
+export interface WaveformConfig {
+    color?: string // The color of the waveform (e.g., "#FFFFFF" for white)
+    opacity?: number // Opacity of the waveform (0.0 - 1.0)
+    strokeWidth?: number // Width of the waveform line (default: 1.5)
+    style?: 'stroke' | 'fill' // Drawing style: "stroke" for outline, "fill" for solid
+    mirror?: boolean // Whether to mirror the waveform (symmetrical display)
+    height?: number // Height of the waveform view in dp (default: 64)
 }
 
 export interface UseAudioRecorderState {