@siteed/expo-audio-stream 1.1.16 → 1.2.0

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 {

package/src/useAudioRecorder.tsx

@@ -48,6 +48,13 @@ interface RecorderReducerState {
 
 type RecorderAction =
     | { type: 'START' | 'STOP' | 'PAUSE' | 'RESUME' }
+    | {
+          type: 'UPDATE_RECORDING_STATE'
+          payload: {
+              isRecording: boolean
+              isPaused: boolean
+          }
+      }
     | { type: 'UPDATE_STATUS'; payload: { durationMs: number; size: number } }
     | { type: 'UPDATE_ANALYSIS'; payload: AudioAnalysis }
 
@@ -87,6 +94,12 @@ function audioRecorderReducer(
             return { ...state, isPaused: true, isRecording: false }
         case 'RESUME':
             return { ...state, isPaused: false, isRecording: true }
+        case 'UPDATE_RECORDING_STATE':
+            return {
+                ...state,
+                isPaused: action.payload.isPaused,
+                isRecording: action.payload.isRecording,
+            }
         case 'UPDATE_STATUS':
             return {
                 ...state,
@@ -128,6 +141,7 @@ export function useAudioRecorder({
     const fullAnalysisRef = useRef<AudioAnalysis>({
         ...defaultAnalysis,
     })
+    const globalIdRef = useRef(0);
 
     // Instantiate the module for web with URLs
     const ExpoAudioStream =
@@ -300,20 +314,40 @@ export function useAudioRecorder({
 
     const checkStatus = useCallback(async () => {
         try {
-            if (!state.isRecording) {
-                logger.debug(`Not recording, exiting status check.`)
-                return
-            }
-
             const status: AudioStreamStatus = ExpoAudioStream.status()
             if (debug) {
-                logger.debug(`Status:`, status)
+                logger.debug(
+                    `Status: paused: ${status.isPaused} durationMs: ${status.durationMs} size: ${status.size}`
+                )
             }
 
-            dispatch({
-                type: 'UPDATE_STATUS',
-                payload: { durationMs: status.durationMs, size: status.size },
-            })
+            // Check and update recording state
+            if (
+                status.isRecording !== state.isRecording ||
+                status.isPaused !== state.isPaused
+            ) {
+                dispatch({
+                    type: 'UPDATE_RECORDING_STATE',
+                    payload: {
+                        isRecording: status.isRecording,
+                        isPaused: status.isPaused,
+                    },
+                })
+            }
+
+            // Check and update recording progress
+            if (
+                status.durationMs !== state.durationMs ||
+                status.size !== state.size
+            ) {
+                dispatch({
+                    type: 'UPDATE_STATUS',
+                    payload: {
+                        durationMs: status.durationMs,
+                        size: status.size,
+                    },
+                })
+            }
         } catch (error) {
             console.error(`${TAG} Error getting status:`, error)
         }
@@ -400,7 +434,7 @@ export function useAudioRecorder({
 
     useEffect(() => {
         let interval: ReturnType<typeof setTimeout>
-        if (state.isRecording) {
+        if (state.isRecording || state.isPaused) {
             interval = setInterval(checkStatus, 1000)
         }
         return () => {
@@ -408,7 +442,7 @@ export function useAudioRecorder({
                 clearInterval(interval)
             }
         }
-    }, [checkStatus, state.isRecording])
+    }, [checkStatus, state.isRecording, state.isPaused])
 
     useEffect(() => {
         logger.debug(`Registering audio event listener`)

package/android/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.values.s

@@ -1 +0,0 @@
-�
�P�xȍ