@siteed/expo-audio-stream 1.1.17 → 1.2.0

package/ios/AudioNotificationManager.swift

@@ -0,0 +1,135 @@
+class AudioNotificationManager {
+    private let notificationCenter = UNUserNotificationCenter.current()
+    private let notificationId = "audio_recording_notification"
+    private var updateTimer: Timer?
+    private var config: NotificationConfig?
+    private var currentDuration: TimeInterval = 0
+    private var lastUpdateTime: Date = Date()
+    private var minUpdateInterval: TimeInterval = 1.0  // Minimum time between updates
+    
+    func initialize(with config: NotificationConfig?) {
+        self.config = config
+        setupNotificationCategories()
+        showInitialNotification()
+    }
+    
+    private func setupNotificationCategories() {
+        let pauseAction = UNNotificationAction(
+            identifier: "PAUSE_RECORDING",
+            title: "Pause",
+            options: [.foreground]
+        )
+        
+        let resumeAction = UNNotificationAction(
+            identifier: "RESUME_RECORDING",
+            title: "Resume",
+            options: [.foreground]
+        )
+        
+        let category = UNNotificationCategory(
+            identifier: config?.ios?.categoryIdentifier ?? "recording_category",
+            actions: [pauseAction, resumeAction],
+            intentIdentifiers: [],
+            options: [.customDismissAction]
+        )
+        
+        notificationCenter.setNotificationCategories([category])
+    }
+    
+    func showInitialNotification() {
+        updateNotification()
+    }
+    
+    func startUpdates(startTime: Date) {
+        DispatchQueue.main.async {
+            self.updateTimer?.invalidate()
+            
+            self.updateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+                guard let self = self else { return }
+                
+                let now = Date()
+                if now.timeIntervalSince(self.lastUpdateTime) >= self.minUpdateInterval {
+                    self.updateNotification()
+                    self.lastUpdateTime = now
+                }
+            }
+            RunLoop.main.add(self.updateTimer!, forMode: .common)
+            
+            self.showInitialNotification()
+        }
+    }
+    
+    func stopUpdates() {
+        DispatchQueue.main.async {
+            self.updateTimer?.invalidate()
+            self.updateTimer = nil
+            
+            self.notificationCenter.removeDeliveredNotifications(withIdentifiers: [self.notificationId])
+            self.notificationCenter.removePendingNotificationRequests(withIdentifiers: [self.notificationId])
+        }
+    }
+    
+    func updateState(isPaused: Bool) {
+        let now = Date()
+        if now.timeIntervalSince(lastUpdateTime) >= minUpdateInterval {
+            updateNotification(forcePauseState: isPaused)
+            lastUpdateTime = now
+        }
+    }
+    
+    func updateDuration(_ duration: TimeInterval) {
+        currentDuration = max(0, duration)
+        let now = Date()
+        if now.timeIntervalSince(lastUpdateTime) >= minUpdateInterval {
+            updateNotification()
+            lastUpdateTime = now
+        }
+    }
+    
+    private func updateNotification(forcePauseState: Bool? = nil) {
+        // First, check if we already have a notification
+        notificationCenter.getDeliveredNotifications { [weak self] notifications in
+            guard let self = self else { return }
+            
+            // If we have a notification and it was recently updated, skip
+            if let existing = notifications.first(where: { $0.request.identifier == self.notificationId }),
+               Date().timeIntervalSince(self.lastUpdateTime) < self.minUpdateInterval {
+                return
+            }
+            
+            // Create notification content
+            let content = UNMutableNotificationContent()
+            content.title = forcePauseState == true ?
+                "Recording Paused" :
+                (self.config?.title ?? "Recording in Progress")
+            
+            let durationText = self.formatDuration(self.currentDuration)
+            let configText = self.config?.text ?? ""
+            content.body = configText.isEmpty ? durationText : "\(configText) - \(durationText)"
+            
+            content.categoryIdentifier = self.config?.ios?.categoryIdentifier ?? "recording_category"
+            content.sound = nil
+            
+            // Create request
+            let request = UNNotificationRequest(
+                identifier: self.notificationId,
+                content: content,
+                trigger: nil
+            )
+            
+            // Replace the existing notification
+            self.notificationCenter.removeDeliveredNotifications(withIdentifiers: [self.notificationId])
+            self.notificationCenter.add(request) { error in
+                if let error = error {
+                    print("Failed to update notification: \(error)")
+                }
+            }
+        }
+    }
+    
+    private func formatDuration(_ duration: TimeInterval) -> String {
+        let minutes = Int(duration) / 60
+        let seconds = Int(duration) % 60
+        return String(format: "%02d:%02d", minutes, seconds)
+    }
+}

package/ios/AudioStreamManager.swift

@@ -8,6 +8,9 @@
 import Foundation
 import AVFoundation
 import Accelerate
+import UIKit
+import MediaPlayer
+import UserNotifications
 
 // Helper to convert to little-endian byte array
 extension UInt32 {
@@ -33,6 +36,10 @@ class AudioStreamManager: NSObject {
     private var audioProcessor: AudioProcessor?
     private var startTime: Date?
     private var pauseStartTime: Date?
+    
+    // Wake lock related properties
+    private var wasIdleTimerDisabled: Bool = false  // Track previous idle timer state
+    private var isWakeLockEnabled: Bool = false     // Track current wake lock state
 
     internal var lastEmissionTime: Date?
     internal var lastEmittedSize: Int64 = 0
@@ -48,12 +55,48 @@ class AudioStreamManager: NSObject {
     private var lastBufferTime: AVAudioTime?
     private var accumulatedData = Data()
     private var recentData = [Float]() // This property stores the recent audio data
+    private var notificationUpdateTimer: Timer?
     
+    private var notificationManager: AudioNotificationManager?
+    private var notificationView: MPNowPlayingInfoCenter?
+    private var audioSession: AVAudioSession?
+    private var notificationObserver: Any?
+    private var mediaInfoUpdateTimer: Timer?
+    private var remoteCommandCenter: MPRemoteCommandCenter?
+
     weak var delegate: AudioStreamManagerDelegate?  // Define the delegate here
     
     /// Initializes the AudioStreamManager
     override init() {
         super.init()
+        // Only keep audio session interruption observer here
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAudioSessionInterruption),
+            name: AVAudioSession.interruptionNotification,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppDidEnterBackground),
+            name: UIApplication.didEnterBackgroundNotification,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppWillEnterForeground),
+            name: UIApplication.willEnterForegroundNotification,
+            object: nil
+        )
+
+    }
+    
+    deinit {
+       // Ensure wake lock is disabled when the manager is deallocated
+       disableWakeLock()
+        if let observer = notificationObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
     }
     
     /// Handles audio session interruptions.
@@ -67,7 +110,7 @@ class AudioStreamManager: NSObject {
         
         Logger.debug("audio session interruption \(type)")
         if type == .began {
-            // Pause your audio recording
+            disableWakeLock()  // Disable wake lock when audio is interrupted
         } else if type == .ended {
             if let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt {
                 let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
@@ -75,11 +118,207 @@ class AudioStreamManager: NSObject {
                     // Resume your audio recording
                     Logger.debug("Resume audio recording \(recordingUUID!)")
                     try? AVAudioSession.sharedInstance().setActive(true)
+                    enableWakeLock()  // Re-enable wake lock when audio resumes
                 }
             }
         }
     }
     
+    private func setupNowPlayingInfo() {
+        // Configure audio session for background audio
+        audioSession = AVAudioSession.sharedInstance()
+        do {
+            try audioSession?.setCategory(.playAndRecord, mode: .default, options: [.allowBluetooth, .mixWithOthers])
+            try audioSession?.setActive(true)
+        } catch {
+            Logger.debug("Failed to configure audio session: \(error)")
+        }
+        
+        // Setup Now Playing info
+        notificationView = MPNowPlayingInfoCenter.default()
+        updateNowPlayingInfo(isPaused: false)
+        
+        // Configure Remote Command Center
+        setupRemoteCommandCenter()
+        
+        // Enable remote control events on main thread
+        DispatchQueue.main.async {
+            UIApplication.shared.beginReceivingRemoteControlEvents()
+        }
+    }
+    
+    private func setupRemoteCommandCenter() {
+        remoteCommandCenter = MPRemoteCommandCenter.shared()
+        
+        // Remove any existing handlers
+        remoteCommandCenter?.pauseCommand.removeTarget(nil)
+        remoteCommandCenter?.playCommand.removeTarget(nil)
+        
+        // Add pause command handler
+        remoteCommandCenter?.pauseCommand.addTarget { [weak self] _ in
+            guard let self = self, self.isRecording && !self.isPaused else {
+                return .commandFailed
+            }
+            self.pauseRecording()
+            return .success
+        }
+        
+        // Add play/resume command handler
+        remoteCommandCenter?.playCommand.addTarget { [weak self] _ in
+            guard let self = self, self.isRecording && self.isPaused else {
+                return .commandFailed
+            }
+            self.resumeRecording()
+            return .success
+        }
+        
+        // Enable the commands
+        remoteCommandCenter?.pauseCommand.isEnabled = true
+        remoteCommandCenter?.playCommand.isEnabled = true
+        
+        // Disable unused commands
+        remoteCommandCenter?.nextTrackCommand.isEnabled = false
+        remoteCommandCenter?.previousTrackCommand.isEnabled = false
+        remoteCommandCenter?.changePlaybackRateCommand.isEnabled = false
+        remoteCommandCenter?.seekBackwardCommand.isEnabled = false
+        remoteCommandCenter?.seekForwardCommand.isEnabled = false
+    }
+    
+    private func updateNowPlayingInfo(isPaused: Bool) {
+        var nowPlayingInfo = [String: Any]()
+        
+        // Set media title and artist
+        nowPlayingInfo[MPMediaItemPropertyTitle] = recordingSettings?.notification?.title ?? "Recording in Progress"
+        nowPlayingInfo[MPMediaItemPropertyArtist] = "Audio Stream"
+        
+        // Set playback state
+        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = isPaused ? 0.0 : 1.0
+        nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentRecordingDuration()
+        
+        // Add placeholder image if available
+        if let image = UIImage(named: "recording_icon") {
+            nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(boundsSize: image.size) { size in
+                return image
+            }
+        }
+        
+        // Update the info on main thread
+        DispatchQueue.main.async {
+            self.notificationView?.nowPlayingInfo = nowPlayingInfo
+        }
+    }
+    
+    private func currentRecordingDuration() -> TimeInterval {
+        guard let startTime = startTime else { return 0 }
+        return Date().timeIntervalSince(startTime) - TimeInterval(pausedDuration)
+    }
+    
+    private func cleanupNotificationObservers() {
+        NotificationCenter.default.removeObserver(self)
+    }
+    
+    @objc private func handlePauseNotification(_ notification: Notification) {
+        // Only handle if recording and notifications are enabled
+        guard isRecording, recordingSettings?.showNotification == true else { return }
+        pauseRecording()
+    }
+    
+    @objc private func handleResumeNotification(_ notification: Notification) {
+        // Only handle if recording and notifications are enabled
+        guard isRecording, recordingSettings?.showNotification == true else { return }
+        resumeRecording()
+    }
+    
+    @objc private func handlePauseAction() {
+        pauseRecording()
+        updateNotificationState(isPaused: true)
+    }
+
+    @objc private func handleResumeAction() {
+        resumeRecording()
+        updateNotificationState(isPaused: false)
+    }
+    
+    @objc private func handleAppDidEnterBackground(_ notification: Notification) {
+        if isRecording {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                self?.notificationManager?.showInitialNotification()
+            }
+        }
+    }
+
+    @objc private func handleAppWillEnterForeground(_ notification: Notification) {
+        if isRecording {
+            notificationManager?.stopUpdates()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                guard let self = self else { return }
+                self.notificationManager?.startUpdates(startTime: self.startTime ?? Date())
+            }
+        }
+    }
+    
+    private func updateNotificationState(isPaused: Bool) {
+        // Calculate current duration
+        let currentDuration: TimeInterval
+        if let startTime = startTime {
+            currentDuration = Date().timeIntervalSince(startTime) - TimeInterval(pausedDuration)
+        } else {
+            currentDuration = 0
+        }
+
+        // Update Now Playing info
+        var nowPlayingInfo = notificationView?.nowPlayingInfo ?? [:]
+        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = isPaused ? 0.0 : 1.0
+        nowPlayingInfo[MPMediaItemPropertyTitle] = isPaused ?
+            "Recording Paused" :
+            (recordingSettings?.notification?.title ?? "Recording in Progress")
+        nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentDuration
+        notificationView?.nowPlayingInfo = nowPlayingInfo
+
+        // Delegate notification update to AudioNotificationManager
+        notificationManager?.updateState(isPaused: isPaused)
+    }
+    
+    private func updateMediaInfo() {
+        guard let startTime = startTime else { return }
+        
+        let currentDuration = Date().timeIntervalSince(startTime) - TimeInterval(pausedDuration)
+        
+        var nowPlayingInfo = notificationView?.nowPlayingInfo ?? [:]
+        nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentDuration
+        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = isPaused ? 0.0 : 1.0
+        notificationView?.nowPlayingInfo = nowPlayingInfo
+    }
+    
+    /// Enables the wake lock to prevent screen dimming
+    private func enableWakeLock() {
+        guard let settings = recordingSettings,
+              settings.keepAwake, // Only proceed if keepAwake is true
+              !isWakeLockEnabled // Only proceed if wake lock isn't already enabled
+        else { return }
+        
+        DispatchQueue.main.async {
+            self.wasIdleTimerDisabled = UIApplication.shared.isIdleTimerDisabled
+            UIApplication.shared.isIdleTimerDisabled = true
+            self.isWakeLockEnabled = true
+            Logger.debug("Wake lock enabled")
+        }
+    }
+    
+    /// Disables the wake lock and restores previous screen dimming state
+    private func disableWakeLock() {
+        guard let settings = recordingSettings,
+              settings.keepAwake, // Only proceed if keepAwake is true
+              isWakeLockEnabled  // Only proceed if wake lock is currently enabled
+        else { return }
+        
+        DispatchQueue.main.async {
+            UIApplication.shared.isIdleTimerDisabled = self.wasIdleTimerDisabled
+            self.isWakeLockEnabled = false
+            Logger.debug("Wake lock disabled")
+        }
+    }
+    
     /// Creates a new recording file.
     /// - Returns: The URL of the newly created recording file, or nil if creation failed.
     private func createRecordingFile() -> URL? {
@@ -201,9 +440,6 @@ class AudioStreamManager: NSObject {
         do {
             Logger.debug("Debug: Configuring audio session with sample rate: \(settings.sampleRate) Hz")
             
-            // Create an audio format with the desired sample rate
-            let desiredFormat = AVAudioFormat(commonFormat: commonFormat, sampleRate: newSettings.sampleRate, channels: UInt32(newSettings.numberOfChannels), interleaved: true)
-            
             // Check if the input node supports the desired format
             let inputNode = audioEngine.inputNode
             let hardwareFormat = inputNode.inputFormat(forBus: 0)
@@ -212,7 +448,11 @@ class AudioStreamManager: NSObject {
                 newSettings.sampleRate = session.sampleRate
             }
             
-            try session.setCategory(.playAndRecord, mode: .default, options: [.allowBluetooth])
+            try session.setCategory(.playAndRecord,
+                mode: .default,
+                options: [.allowBluetooth, .defaultToSpeaker, .mixWithOthers]
+            )
+
             try session.setPreferredSampleRate(settings.sampleRate)
             try session.setPreferredIOBufferDuration(1024 / settings.sampleRate)
             try session.setActive(true)
@@ -225,6 +465,7 @@ class AudioStreamManager: NSObject {
             }
             
             recordingSettings = newSettings  // Update the class property with the new settings
+            enableWakeLock() // Will only enable if keepAwake is true
         } catch {
             Logger.debug("Error: Failed to set up audio session with preferred settings: \(error.localizedDescription)")
             return nil
@@ -267,6 +508,10 @@ class AudioStreamManager: NSObject {
             return nil
         }
         
+        if settings.showNotification {
+            initializeNotifications()
+        }
+        
         do {
             startTime = Date()
             try audioEngine.start()
@@ -288,25 +533,74 @@ class AudioStreamManager: NSObject {
     
     /// Pauses the current audio recording.
     func pauseRecording() {
-        guard isRecording && !isPaused else {
-            Logger.debug("Recording is not in progress or already paused.")
-            return
-        }
+        guard isRecording && !isPaused else { return }
         
+        disableWakeLock()
         audioEngine.pause()
         isPaused = true
         pauseStartTime = Date()
         
+        updateNowPlayingInfo(isPaused: true)
+        notificationManager?.updateState(isPaused: true)
+        delegate?.audioStreamManager(self, didPauseRecording: Date())
+        delegate?.audioStreamManager(self, didUpdateNotificationState: true)
+        
         Logger.debug("Recording paused.")
     }
     
+    private func initializeNotifications() {
+        guard recordingSettings?.showNotification == true else { return }
+        
+        // Setup notification manager if not already initialized
+        if notificationManager == nil {
+            UNUserNotificationCenter.current().delegate = self
+            
+            notificationManager = AudioNotificationManager()
+            
+            // Request permissions first
+            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+                if granted {
+                    DispatchQueue.main.async {
+                        self.notificationManager?.initialize(with: self.recordingSettings?.notification)
+                        self.setupNowPlayingInfo()
+                        
+                        // Start media info update timer
+                        self.mediaInfoUpdateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+                           self?.updateMediaInfo()
+                        }
+                        
+                        // Setup notification observers
+                        NotificationCenter.default.addObserver(
+                            self,
+                            selector: #selector(self.handlePauseNotification),
+                            name: .pauseRecording,
+                            object: nil
+                        )
+                        
+                        NotificationCenter.default.addObserver(
+                            self,
+                            selector: #selector(self.handleResumeNotification),
+                            name: .resumeRecording,
+                            object: nil
+                        )
+                        
+                        // Start updates if recording is already in progress
+                        if let startTime = self.startTime {
+                            self.notificationManager?.startUpdates(startTime: startTime)
+                        }
+                    }
+                } else if let error = error {
+                    Logger.debug("Failed to get notification permission: \(error.localizedDescription)")
+                }
+            }
+        }
+    }
+    
     /// Resumes the current audio recording.
     func resumeRecording() {
-        guard isRecording && isPaused else {
-            Logger.debug("Recording is not in progress or not paused.")
-            return
-        }
+        guard isRecording && isPaused else { return }
         
+        enableWakeLock()
         audioEngine.prepare()
         do {
             try audioEngine.start()
@@ -314,6 +608,12 @@ class AudioStreamManager: NSObject {
             if let pauseStartTime = pauseStartTime {
                 pausedDuration += Int(Date().timeIntervalSince(pauseStartTime))
             }
+            
+            updateNowPlayingInfo(isPaused: false)
+            notificationManager?.updateState(isPaused: false)
+            delegate?.audioStreamManager(self, didResumeRecording: Date())
+            delegate?.audioStreamManager(self, didUpdateNotificationState: false)
+            
             Logger.debug("Recording resumed.")
         } catch {
             Logger.debug("Error: Failed to resume recording: \(error.localizedDescription)")
@@ -347,10 +647,32 @@ class AudioStreamManager: NSObject {
     /// Stops the current audio recording.
     /// - Returns: A RecordingResult object if the recording stopped successfully, or nil otherwise.
     func stopRecording() -> RecordingResult? {
+        disableWakeLock() // Will only disable if keepAwake is true
         audioEngine.stop()
         audioEngine.inputNode.removeTap(onBus: 0)
         isRecording = false
         
+        if recordingSettings?.showNotification == true {
+            // Stop and clean up timer
+            mediaInfoUpdateTimer?.invalidate()
+            mediaInfoUpdateTimer = nil
+            
+            // Clean up notification manager
+            notificationManager?.stopUpdates()
+            notificationManager = nil
+            
+            // Clean up media controls
+            DispatchQueue.main.async {
+                UIApplication.shared.endReceivingRemoteControlEvents()
+                self.remoteCommandCenter?.pauseCommand.isEnabled = false
+                self.remoteCommandCenter?.playCommand.isEnabled = false
+                self.notificationView?.nowPlayingInfo = nil
+            }
+            
+            // Clean up audio session
+            try? audioSession?.setActive(false)
+        }
+        
         guard let fileURL = recordingFileURL, let startTime = startTime, let settings = recordingSettings else {
             Logger.debug("Recording or file URL is nil.")
             return nil
@@ -502,6 +824,22 @@ class AudioStreamManager: NSObject {
         }
     }
     
+    private func updateNotificationDuration() {
+        guard let startTime = startTime,
+              recordingSettings?.showNotification == true else { return }
+        
+        let currentDuration = Date().timeIntervalSince(startTime) - TimeInterval(pausedDuration)
+        
+        // Update both notification manager and media player
+        notificationManager?.updateDuration(currentDuration)
+        
+        if let notificationView = notificationView {
+            var nowPlayingInfo = notificationView.nowPlayingInfo ?? [:]
+            nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentDuration
+            notificationView.nowPlayingInfo = nowPlayingInfo
+        }
+    }
+    
     /// Processes the audio buffer and writes data to the file. Also handles audio processing if enabled.
     /// - Parameters:
     ///   - buffer: The audio buffer to process.
@@ -553,6 +891,10 @@ class AudioStreamManager: NSObject {
         totalDataSize += Int64(data.count)
         //        print("Total data size written: \(totalDataSize) bytes")  // Debug: Check total data written
         
+        if recordingSettings?.showNotification == true {
+            updateNotificationDuration()
+        }
+        
         let currentTime = Date()
         if let lastEmissionTime = lastEmissionTime, currentTime.timeIntervalSince(lastEmissionTime) >= emissionInterval {
             if let startTime = startTime {
@@ -598,3 +940,35 @@ class AudioStreamManager: NSObject {
         }
     }
 }
+
+extension AudioStreamManager: UNUserNotificationCenterDelegate {
+    func userNotificationCenter(
+        _ center: UNUserNotificationCenter,
+        didReceive response: UNNotificationResponse,
+        withCompletionHandler completionHandler: @escaping () -> Void
+    ) {
+        switch response.actionIdentifier {
+        case "PAUSE_RECORDING":
+            pauseRecording()
+        case "RESUME_RECORDING":
+            resumeRecording()
+        default:
+            break
+        }
+        completionHandler()
+    }
+
+    // This is needed to show notifications when app is in foreground
+    func userNotificationCenter(
+            _ center: UNUserNotificationCenter,
+            willPresent notification: UNNotification,
+            withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+        ) {
+            if #available(iOS 14.0, *) {
+                completionHandler([.banner, .sound])
+            } else {
+                // For iOS 13 and earlier
+                completionHandler([.alert, .sound])
+            }
+        }
+}

package/ios/AudioStreamManagerDelegate.swift

@@ -1,4 +1,8 @@
 protocol AudioStreamManagerDelegate: AnyObject {
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveAudioData data: Data, recordingTime: TimeInterval, totalDataSize: Int64)
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveProcessingResult result: AudioAnalysisData?)
+    
+    func audioStreamManager(_ manager: AudioStreamManager, didPauseRecording pauseTime: Date)
+    func audioStreamManager(_ manager: AudioStreamManager, didResumeRecording resumeTime: Date)
+    func audioStreamManager(_ manager: AudioStreamManager, didUpdateNotificationState isPaused: Bool)
 }