@siteed/expo-audio-stream 1.16.0 → 2.0.0

package/ios/AudioStreamManager.swift

@@ -44,17 +44,29 @@ class AudioStreamManager: NSObject {
     private var wasIdleTimerDisabled: Bool = false  // Track previous idle timer state
     private var isWakeLockEnabled: Bool = false     // Track current wake lock state
 
+
+    // Data emission for onAudioStream
     internal var lastEmissionTime: Date?
     internal var lastEmittedSize: Int64 = 0
     internal var lastEmittedCompressedSize: Int64 = 0
-    private var emissionInterval: TimeInterval = 1.0 // Default to 1 second
     private var totalDataSize: Int64 = 0
+    private var lastBufferTime: AVAudioTime?
+    private var accumulatedData = Data()
+
+    // Data emission for onAudioAnalysis
+    internal var lastEmissionTimeAnalysis: Date?
+    internal var lastEmittedSizeAnalysis: Int64 = 0
+    internal var lastEmittedCompressedSizeAnalysis: Int64 = 0
+    private var totalDataSizeAnalysis: Int64 = 0
+    private var lastBufferTimeAnalysis: AVAudioTime?
+    private var accumulatedAnalysisData = Data()
+
+
+
     private var fileManager = FileManager.default
     internal var recordingSettings: RecordingSettings?
     internal var recordingUUID: UUID?
     internal var mimeType: String = "audio/wav"
-    private var lastBufferTime: AVAudioTime?
-    private var accumulatedData = Data()
     private var recentData = [Float]() // This property stores the recent audio data
     private var notificationUpdateTimer: Timer?
     
@@ -77,6 +89,10 @@ class AudioStreamManager: NSObject {
     // Add property to track auto-resume preference
     private var autoResumeAfterInterruption: Bool = false
     
+    // Add these properties
+    private var emissionInterval: TimeInterval = 1.0  // Default 1 second
+    private var emissionIntervalAnalysis: TimeInterval = 0.5  // Default 0.5 seconds
+
     /// Initializes the AudioStreamManager
     override init() {
         super.init()
@@ -537,7 +553,8 @@ class AudioStreamManager: NSObject {
             "isPaused": isPaused,
             "mimeType": mimeType,
             "size": totalDataSize,
-            "interval": emissionInterval
+            "interval": settings.interval,
+            "intervalAnalysis": settings.intervalAnalysis
         ]
         
         // Add compression info if enabled
@@ -575,12 +592,11 @@ class AudioStreamManager: NSObject {
                audioSession.currentRoute.outputs.contains { $0.portType == .builtInReceiver }
     }
 
-    /// Starts a new audio recording with the specified settings and interval.
+    /// Starts a new audio recording with the specified settings.
     /// - Parameters:
     ///   - settings: The recording settings to use.
-    ///   - intervalMilliseconds: The interval in milliseconds for emitting audio data.
     /// - Returns: A StartRecordingResult object if recording starts successfully, or nil otherwise.
-    func startRecording(settings: RecordingSettings, intervalMilliseconds: Int) -> StartRecordingResult? {
+    func startRecording(settings: RecordingSettings) -> StartRecordingResult? {
         // Check for active call using the new method
         if isPhoneCallActive() {
             Logger.debug("Cannot start recording during an active phone call")
@@ -619,14 +635,19 @@ class AudioStreamManager: NSObject {
         let session = AVAudioSession.sharedInstance()
         var newSettings = settings
         
-        // Add these initializations back
-        emissionInterval = max(100.0, Double(intervalMilliseconds)) / 1000.0
+        emissionInterval = max(100.0, Double(settings.interval ?? 1000)) / 1000.0
+        emissionIntervalAnalysis = max(100.0, Double(settings.intervalAnalysis ?? 500)) / 1000.0
         lastEmissionTime = Date()
+        lastEmissionTimeAnalysis = Date()
         accumulatedData.removeAll()
+        accumulatedAnalysisData.removeAll()
         totalDataSize = 0
+        totalDataSizeAnalysis = 0
         totalPausedDuration = 0
         lastEmittedSize = 0
+        lastEmittedCompressedSizeAnalysis = 0
         isPaused = false
+
         
         // Create recording file first
         recordingFileURL = createRecordingFile()
@@ -677,6 +698,12 @@ class AudioStreamManager: NSObject {
                 - mode: \(mode)
                 - options: \(options)
                 - keepAwake: \(settings.keepAwake)
+                - emission interval: \(emissionInterval * 1000)ms
+                - analysis interval: \(emissionIntervalAnalysis * 1000)ms
+                - sample rate: \(settings.sampleRate)Hz
+                - channels: \(settings.numberOfChannels)
+                - bit depth: \(settings.bitDepth)-bit
+                - compression enabled: \(settings.enableCompressedOutput)
             """)
             
             try session.setPreferredSampleRate(settings.sampleRate)
@@ -860,7 +887,7 @@ class AudioStreamManager: NSObject {
     }
     
     /// Pauses the current audio recording.
-    func pauseRecording() {
+    public func pauseRecording() {
         guard isRecording && !isPaused else { return }
         
         // Store the current duration when pausing
@@ -929,8 +956,8 @@ class AudioStreamManager: NSObject {
     }
     
     /// Resumes the current audio recording.
-    func resumeRecording() {
-        // Check for active call using the new method
+    public func resumeRecording() {
+        // Check for active phone call
         if isPhoneCallActive() {
             Logger.debug("Cannot resume recording during an active phone call")
             delegate?.audioStreamManager(self, didFailWithError: "Cannot resume recording during an active phone call")
@@ -987,7 +1014,7 @@ class AudioStreamManager: NSObject {
         return formatDescription
     }
     
-    private func describeCommonFormat(_ format: AVAudioCommonFormat) -> String {
+    func describeCommonFormat(_ format: AVAudioCommonFormat) -> String {
         switch format {
         case .pcmFormatFloat32:
             return "32-bit float"
@@ -1149,9 +1176,12 @@ class AudioStreamManager: NSObject {
             totalPausedDuration = 0
             currentPauseStart = nil
             lastEmissionTime = nil
+            lastEmissionTimeAnalysis = nil
             lastEmittedSize = 0
+            lastEmittedSizeAnalysis = 0
             lastEmittedCompressedSize = 0
             accumulatedData.removeAll()
+            accumulatedAnalysisData.removeAll()
             recordingUUID = nil
             
             return result
@@ -1459,6 +1489,7 @@ class AudioStreamManager: NSObject {
         // Update total size and accumulated data
         totalDataSize += Int64(data.count)
         accumulatedData.append(data)
+        accumulatedAnalysisData.append(data)
         
         // Handle notifications if enabled
         if recordingSettings?.showNotification == true {
@@ -1534,7 +1565,21 @@ class AudioStreamManager: NSObject {
                 compressionInfo: compressionInfo
             )
             
-            // Process audio if enabled
+            // Update state after emission
+            self.lastEmissionTime = currentTime
+            self.lastEmittedSize = totalDataSize
+            accumulatedData.removeAll()
+        }
+
+
+        if let lastEmissionTimeAnalysis = lastEmissionTimeAnalysis,
+           let startTime = startTime,
+           currentTime.timeIntervalSince(lastEmissionTimeAnalysis) >= emissionIntervalAnalysis {
+            
+            let recordingTime = currentTime.timeIntervalSince(startTime)
+            let dataToProcess = accumulatedAnalysisData
+
+                       // Process audio if enabled
             if settings.enableProcessing {
                 DispatchQueue.global().async { [weak self] in
                     guard let self = self else { return }
@@ -1543,9 +1588,8 @@ class AudioStreamManager: NSObject {
                         let processingResult = processor.processAudioBuffer(
                             data: dataToProcess,
                             sampleRate: Float(settings.sampleRate),
-                            pointsPerSecond: settings.pointsPerSecond ?? 10,
-                            algorithm: settings.algorithm ?? "rms",
-                            featureOptions: settings.featureOptions ?? ["rms": true, "zcr": true],
+                            segmentDurationMs: settings.segmentDurationMs,
+                            featureOptions: settings.featureOptions ?? [:],
                             bitDepth: settings.bitDepth,
                             numberOfChannels: settings.numberOfChannels
                         )
@@ -1555,14 +1599,14 @@ class AudioStreamManager: NSObject {
                                 self.delegate?.audioStreamManager(self, didReceiveProcessingResult: result)
                             }
                         }
+
+                            // Update state after emission
+                        self.lastEmissionTimeAnalysis = currentTime
+                        self.lastEmittedSizeAnalysis = totalDataSizeAnalysis
+                        accumulatedAnalysisData.removeAll()
                     }
                 }
             }
-            
-            // Update state after emission
-            self.lastEmissionTime = currentTime
-            self.lastEmittedSize = totalDataSize
-            accumulatedData.removeAll()
         }
     }
 

package/ios/DataPoint.swift

@@ -7,19 +7,31 @@
 
 import Foundation
 
+public struct SpeechFeatures {
+    public var isActive: Bool
+    public var speakerId: Int?
+    
+    func toDictionary() -> [String: Any] {
+        return [
+            "isActive": isActive,
+            "speakerId": speakerId as Any
+        ]
+    }
+}
 
 public struct DataPoint {
     public var id: Int
     public var amplitude: Float
-    public var activeSpeech: Bool?
-    public var dB: Float?
-    public var silent: Bool?
+    public var rms: Float
+    public var dB: Float
+    public var silent: Bool
     public var features: Features?
-    public var startTime: Float?
-    public var endTime: Float?
-    public var startPosition: Int?
-    public var endPosition: Int?
-    public var speaker: Int?
+    public var speech: SpeechFeatures?
+    public let startTime: Float // in seconds
+    public let endTime: Float   // in seconds
+    public let startPosition: Int // byte position in audio file
+    public let endPosition: Int   // byte position in audio file
+    public let samples: Int       // number of samples in segment
 }
 
 extension DataPoint {
@@ -27,15 +39,16 @@ extension DataPoint {
         return [
             "id": id,
             "amplitude": amplitude,
-            "activeSpeech": activeSpeech ?? false,
-            "dB": dB ?? 0,
-            "silent": silent ?? false,
+            "rms": rms,
+            "dB": dB,
+            "silent": silent,
             "features": features?.toDictionary() ?? [:],
+            "speech": speech?.toDictionary() ?? [:],
             "startTime": startTime ?? 0,
             "endTime": endTime ?? 0,
             "startPosition": startPosition ?? 0,
             "endPosition": endPosition ?? 0,
-            "speaker": speaker ?? 0
+            "samples": samples ?? 0
         ]
     }
 }

package/ios/DecodingConfig.swift

@@ -0,0 +1,47 @@
+//
+//  DecodingConfig.swift
+//  Pods
+//
+//  Created by Arthur Breton on 24/2/2025.
+//
+
+import AVFoundation
+
+public struct DecodingConfig {
+    let targetSampleRate: Double?
+    let targetChannels: Int?
+    let targetBitDepth: Int?
+    let normalizeAudio: Bool
+    
+    static func fromDictionary(_ dict: [String: Any]?) -> DecodingConfig {
+        guard let dict = dict else {
+            return DecodingConfig.default
+        }
+        
+        return DecodingConfig(
+            targetSampleRate: dict["targetSampleRate"] as? Double,
+            targetChannels: dict["targetChannels"] as? Int,
+            targetBitDepth: dict["targetBitDepth"] as? Int,
+            normalizeAudio: dict["normalizeAudio"] as? Bool ?? false
+        )
+    }
+    
+    static var `default`: DecodingConfig {
+        return DecodingConfig(
+            targetSampleRate: nil,
+            targetChannels: nil,
+            targetBitDepth: nil,
+            normalizeAudio: false
+        )
+    }
+    
+    func toAudioFormat(baseFormat: AVAudioFormat) -> AVAudioFormat {
+        let sampleRate = targetSampleRate ?? baseFormat.sampleRate
+        let channels = targetChannels ?? Int(baseFormat.channelCount)
+        
+        return AVAudioFormat(
+            standardFormatWithSampleRate: sampleRate,
+            channels: AVAudioChannelCount(channels)
+        )!
+    }
+}