[Fix]Local audio waveform not always working (#912)

Author: ipavlidakis

CHANGELOG.md

@@ -4,7 +4,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 # Upcoming
 
-### 🔄 Changed
+### 🐞 Fixed
+- An issue that was causing the local participant's audio waveform visualization to stop working. [#912](https://github.com/GetStream/stream-video-swift/pull/912)
 
 # [1.30.0](https://github.com/GetStream/stream-video-swift/releases/tag/1.30.0)
 _August 08, 2025_

Sources/StreamVideo/StreamVideo.swift

@@ -188,9 +188,6 @@ public class StreamVideo: ObservableObject, @unchecked Sendable {
             middlewares: [defaultParams]
         )
         StreamVideoProviderKey.currentValue = self
-        // This is used from the `StreamCallAudioRecorder` to observe active
-        // calls and activate/deactivate the AudioSession.
-        StreamActiveCallProviderKey.currentValue = self
 
         // Update the streamVideo instance on the noiseCancellationFilter
         // to allow it to observe the activeCall state.

Sources/StreamVideo/Utils/AudioSession/AudioRecorder/AVAudioRecorderBuilder.swift

@@ -0,0 +1,106 @@
+//
+// Copyright © 2025 Stream.io Inc. All rights reserved.
+//
+
+import AVFoundation
+import Foundation
+
+/// Convenience extensions for `AVAudioRecorder` to simplify audio recording
+/// setup.
+extension AVAudioRecorder {
+
+    /// Creates a new audio recorder with default settings optimized for voice
+    /// recording.
+    ///
+    /// This convenience method simplifies recorder creation by:
+    /// - Automatically selecting the app's cache directory for storage
+    /// - Providing sensible default recording settings for voice
+    /// - Handling file URL construction
+    ///
+    /// ## Default Settings
+    ///
+    /// The default settings are optimized for voice recording:
+    /// - **Format**: Linear PCM (uncompressed, highest quality)
+    /// - **Sample Rate**: 12 kHz (suitable for voice)
+    /// - **Channels**: Mono (single channel)
+    /// - **Quality**: High
+    ///
+    /// ## File Storage
+    ///
+    /// Audio files are stored in the app's cache directory, which:
+    /// - Doesn't require user permission
+    /// - Is automatically managed by iOS
+    /// - Can be cleared when device storage is low
+    ///
+    /// ## Usage Example
+    ///
+    /// ```swift
+    /// // Create recorder with default settings
+    /// let recorder = try AVAudioRecorder.build()
+    ///
+    /// // Create recorder with custom filename
+    /// let customRecorder = try AVAudioRecorder.build(
+    ///     filename: "interview.wav"
+    /// )
+    ///
+    /// // Create recorder with custom settings
+    /// let highQualityRecorder = try AVAudioRecorder.build(
+    ///     filename: "music.wav",
+    ///     settings: [
+    ///         AVFormatIDKey: Int(kAudioFormatLinearPCM),
+    ///         AVSampleRateKey: 44100,
+    ///         AVNumberOfChannelsKey: 2,
+    ///         AVEncoderAudioQualityKey: AVAudioQuality.max.rawValue
+    ///     ]
+    /// )
+    /// ```
+    ///
+    /// - Parameters:
+    ///   - filename: The name of the audio file to create. Defaults to
+    ///     "recording.wav". The file will be stored in the app's cache
+    ///     directory.
+    ///   - settings: Dictionary of audio recording settings. Defaults to
+    ///     settings optimized for voice recording. See `AVAudioRecorder`
+    ///     documentation for available keys.
+    ///
+    /// - Returns: A configured `AVAudioRecorder` instance ready for
+    ///   recording.
+    ///
+    /// - Throws: An error if the recorder cannot be initialized, typically
+    ///   due to:
+    ///   - Invalid recording settings
+    ///   - File system errors
+    ///   - Audio session configuration issues
+    ///
+    /// - Note: Remember to configure the audio session and request microphone
+    ///   permission before attempting to record.
+    ///
+    /// - Important: Linear PCM format is used by default to support multiple
+    ///   simultaneous `AVAudioRecorder` instances. Compressed formats may
+    ///   limit you to a single recorder at a time.
+    static func build(
+        filename: String = "recording.wav",
+        settings: [String: Any] = [
+            AVFormatIDKey: Int(kAudioFormatLinearPCM),
+            AVSampleRateKey: 12000,
+            AVNumberOfChannelsKey: 1,
+            AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
+        ]
+    ) throws -> AVAudioRecorder {
+        // Get the cache directory for temporary audio storage
+        guard
+            let documentPath = FileManager.default.urls(
+                for: .cachesDirectory,
+                in: .userDomainMask
+            ).first
+        else {
+            throw ClientError("No cache directory available.")
+        }
+
+        // Construct the full file URL
+        let fileURL = documentPath.appendingPathComponent(filename)
+        
+        // Create and return the configured recorder
+        return try .init(url: fileURL, settings: settings)
+    }
+}

Sources/StreamVideo/Utils/AudioSession/AudioRecorder/Extensions/AVAudioRecorder+Convenience.swift

@@ -0,0 +1,165 @@
+//
+// Copyright © 2025 Stream.io Inc. All rights reserved.
+//
+
+import AVFoundation
+import Combine
+import Foundation
+
+extension StreamCallAudioRecorder.Namespace {
+    /// Middleware that manages the `AVAudioRecorder` instance for audio
+    /// recording.
+    ///
+    /// This middleware handles:
+    /// - Creating and configuring the audio recorder
+    /// - Starting and stopping recording based on state changes
+    /// - Publishing audio meter levels at the display refresh rate
+    /// - Managing recording permissions
+    ///
+    /// ## Thread Safety
+    ///
+    /// Recording operations are performed on a serial operation queue to
+    /// ensure thread safety when accessing the recorder instance.
+    final class AVAudioRecorderMiddleware: Middleware<StreamCallAudioRecorder.Namespace>, @unchecked Sendable {
+
+        /// The audio store for managing permissions and session state.
+        @Injected(\.audioStore) private var audioStore
+
+        /// Builder for creating and caching the audio recorder instance.
+        private var audioRecorder: AVAudioRecorder?
+
+        /// Serial queue for recorder operations to ensure thread safety.
+        private let processingQueue = OperationQueue(maxConcurrentOperationCount: 1)
+        
+        /// Subscription for publishing meter updates at refresh rate.
+        private var updateMetersCancellable: AnyCancellable?
+
+        init(audioRecorder: AVAudioRecorder? = nil) {
+            self.audioRecorder = audioRecorder
+        }
+
+        // MARK: - Middleware
+
+        /// Processes actions to manage audio recording state.
+        ///
+        /// Responds to:
+        /// - `.setIsRecording`: Starts or stops recording
+        /// - `.setIsInterrupted`: Pauses recording during interruptions
+        /// - `.setShouldRecord`: Initiates recording when needed
+        ///
+        /// - Parameters:
+        ///   - state: The current store state.
+        ///   - action: The action being processed.
+        ///   - file: Source file of the action dispatch.
+        ///   - function: Function name of the action dispatch.
+        ///   - line: Line number of the action dispatch.
+        override func apply(
+            state: State,
+            action: Action,
+            file: StaticString,
+            function: StaticString,
+            line: UInt
+        ) {
+            switch action {
+            case let .setIsRecording(value):
+                if value, state.shouldRecord {
+                    startRecording()
+                } else {
+                    stopRecording()
+                }
+            case let .setIsInterrupted(value):
+                if value {
+                    stopRecording()
+                } else if !value, state.shouldRecord, !state.isRecording {
+                    startRecording()
+                } else {
+                    break
+                }
+
+            case let .setShouldRecord(value):
+                if value, !state.isRecording {
+                    startRecording()
+                } else if !value, state.isRecording {
+                    stopRecording()
+                } else {
+                    break
+                }
+
+            case .setMeter:
+                break
+            }
+        }
+
+        // MARK: - Private Helpers
+
+        /// Starts audio recording asynchronously.
+        ///
+        /// This method:
+        /// 1. Builds the audio recorder if needed
+        /// 2. Requests recording permission
+        /// 3. Enables metering and starts recording
+        /// 4. Sets up a timer to publish meter updates
+        private func startRecording() {
+            processingQueue.addTaskOperation { [weak self] in
+                guard
+                    let self,
+                    updateMetersCancellable == nil
+                else {
+                    return
+                }
+
+                if audioRecorder == nil {
+                    do {
+                        self.audioRecorder = try AVAudioRecorder.build()
+                    } catch {
+                        log.error(error, subsystems: .audioRecording)
+                        return
+                    }
+                }
+
+                guard let audioRecorder else {
+                    return
+                }
+
+                audioRecorder.isMeteringEnabled = true
+                guard
+                    await audioStore.requestRecordPermission(),
+                    audioRecorder.record()
+                else {
+                    dispatcher?.dispatch(.setIsRecording(false))
+                    audioRecorder.isMeteringEnabled = false
+                    return
+                }
+
+                updateMetersCancellable = DefaultTimer
+                    .publish(every: ScreenPropertiesAdapter.currentValue.refreshRate)
+                    .map { [weak audioRecorder] _ in audioRecorder?.updateMeters() }
+                    .compactMap { [weak audioRecorder] in audioRecorder?.averagePower(forChannel: 0) }
+                    .sink { [weak self] in self?.dispatcher?.dispatch(.setMeter($0)) }
+            }
+        }
+
+        /// Stops audio recording and cleans up resources.
+        ///
+        /// This method:
+        /// 1. Stops the active recording
+        /// 2. Disables metering
+        /// 3. Cancels the meter update timer
+        private func stopRecording() {
+            processingQueue.addOperation { [weak self] in
+                guard
+                    let self,
+                    updateMetersCancellable != nil,
+                    let audioRecorder
+                else {
+                    return
+                }
+
+                audioRecorder.stop()
+                audioRecorder.isMeteringEnabled = false
+                updateMetersCancellable?.cancel()
+                updateMetersCancellable = nil
+            }
+        }
+    }
+}