[Enhancement]Rework audio-system with ADM

[Enhancement]Move audioLevel observation to the AudioEngine

Reworked audiosession management with ADM

# Conflicts:
#	Sources/StreamVideo/Utils/AudioSession/CallAudioSession.swift
#	Sources/StreamVideo/Utils/AudioSession/Policies/DefaultAudioSessionPolicy.swift

# Conflicts:
#	Sources/StreamVideo/Utils/AudioSession/CallAudioSession.swift
#	Sources/StreamVideo/Utils/AudioSession/Extensions/AVAudioSession.CategoryOptions+Convenience.swift
#	Sources/StreamVideo/Utils/AudioSession/RTCAudioStore/Effects/RTCAudioStore+RouteChangeEffect.swift

Attemp to fix issues with Alexey

Author: ipavlidakis

DemoApp/Sources/ViewModifiers/MoreControls/DemoMoreControlsViewModifier.swift

@@ -53,7 +53,12 @@ struct DemoMoreControlsViewModifier: ViewModifier {
                             }
 
                             DemoMoreControlListButtonView(
-                                action: { viewModel.toggleAudioOutput() },
+                                action: {
+                                    if viewModel.callSettings.audioOn {
+                                        viewModel.toggleMicrophoneEnabled()
+                                    }
+                                    viewModel.toggleAudioOutput()
+                                },
                                 label: viewModel.callSettings.audioOutputOn ? "Disable audio output" : "Enable audio output"
                             ) {
                                 Image(

Sources/StreamVideo/CallKit/CallKitService.swift

@@ -11,11 +11,17 @@ import StreamWebRTC
 /// Manages CallKit integration for VoIP calls.
 open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
 
+    struct MuteRequest: Equatable {
+        var callUUID: UUID
+        var isMuted: Bool
+    }
+
     @Injected(\.callCache) private var callCache
     @Injected(\.uuidFactory) private var uuidFactory
     @Injected(\.currentDevice) private var currentDevice
     @Injected(\.audioStore) private var audioStore
     @Injected(\.permissions) private var permissions
+    @Injected(\.applicationStateAdapter) private var applicationStateAdapter
     private let disposableBag = DisposableBag()
 
     /// Represents a call that is being managed by the service.
@@ -91,17 +97,17 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
 
     private var _storage: [UUID: CallEntry] = [:]
     private let storageAccessQueue: UnfairQueue = .init()
-    private var active: UUID? {
-        didSet { observeCallSettings(active) }
-    }
+    private var active: UUID?
 
     var callCount: Int { storageAccessQueue.sync { _storage.count } }
 
     private var callEndedNotificationCancellable: AnyCancellable?
     private var ringingTimerCancellable: AnyCancellable?
 
-    /// Handles audio session changes triggered by CallKit.
-    private lazy var callKitAudioReducer = CallKitAudioSessionReducer(store: audioStore)
+    private let muteActionSubject = PassthroughSubject<MuteRequest, Never>()
+    private var muteActionCancellable: AnyCancellable?
+    private let muteProcessingQueue = OperationQueue(maxConcurrentOperationCount: 1)
+    private var isMuted = false
 
     /// Initialize.
     override public init() {
@@ -113,6 +119,18 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
             .publisher(for: Notification.Name(CallNotification.callEnded))
             .compactMap { $0.object as? Call }
             .sink { [weak self] in self?.callEnded($0.cId, ringingTimedOut: false) }
+
+        /// - Important:
+        /// It used to debounce System's attempts to mute/unmute the call. It seems that the system
+        /// performs rapid mute/unmute attempts when the call is being joined or moving to foreground.
+        /// The observation below is in place to guard and normalise those attempts to avoid
+        /// - rapid speaker and mic toggles
+        /// - unnecessary attempts to mute/unmute the mic
+        muteActionCancellable = muteActionSubject
+            .removeDuplicates()
+            .filter { [weak self] _ in self?.applicationStateAdapter.state != .foreground }
+            .debounce(for: 0.5, scheduler: DispatchQueue.global(qos: .userInteractive))
+            .sink { [weak self] in self?.performMuteRequest($0) }
     }
 
     /// Report an incoming call to CallKit.
@@ -394,6 +412,8 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
         ///
         /// of the audio session during a call.
         audioStore.dispatch(.callKit(.activate(audioSession)))
+
+        observeCallSettings(active)
     }
 
     public func provider(
@@ -463,27 +483,6 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
                 log.error(error, subsystems: .callKit)
                 action.fail()
             }
-
-            let callSettings = callToJoinEntry.call.state.callSettings
-            do {
-                if callSettings.audioOn == false {
-                    try await requestTransaction(
-                        CXSetMutedCallAction(
-                            call: callToJoinEntry.callUUID,
-                            muted: true
-                        )
-                    )
-                }
-            } catch {
-                log.error(
-                    """
-                    While joining call id:\(callToJoinEntry.call.cId) we failed to mute the microphone.
-                    \(callSettings)
-                    """,
-                    subsystems: .callKit,
-                    error: error
-                )
-            }
         }
     }
 
@@ -555,33 +554,23 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
             action.fail()
             return
         }
-        Task(disposableBag: disposableBag) { [permissions] in
-            guard permissions.hasMicrophonePermission else {
-                if action.isMuted {
-                    action.fulfill()
-                } else {
-                    action.fail()
-                }
-                return
-            }
 
-            do {
-                if action.isMuted {
-                    stackEntry.call.didPerform(.performSetMutedCall)
-                    try await stackEntry.call.microphone.disable()
-                } else {
-                    stackEntry.call.didPerform(.performSetMutedCall)
-                    try await stackEntry.call.microphone.enable()
-                }
-            } catch {
-                log.error(
-                    "Unable to perform muteCallAction isMuted:\(action.isMuted).",
-                    subsystems: .callKit,
-                    error: error
-                )
+        guard permissions.hasMicrophonePermission else {
+            if action.isMuted {
+                action.fulfill()
+            } else {
+                action.fail()
             }
-            action.fulfill()
+            return
         }
+
+        muteActionSubject.send(
+            .init(
+                callUUID: stackEntry.callUUID,
+                isMuted: action.isMuted
+            )
+        )
+        action.fulfill()
     }
 
     // MARK: - Helpers
@@ -639,12 +628,6 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
     /// Called when `StreamVideo` changes. Adds/removes the audio reducer and
     /// subscribes to events on real devices.
     open func didUpdate(_ streamVideo: StreamVideo?) {
-        if streamVideo != nil {
-            audioStore.add(callKitAudioReducer)
-        } else {
-            audioStore.remove(callKitAudioReducer)
-        }
-
         guard currentDevice.deviceType != .simulator else {
             return
         }
@@ -796,19 +779,63 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
                 .call
                 .state
                 .$callSettings
-                .map { !$0.audioOn }
+                .map { $0.audioOn == false }
                 .removeDuplicates()
                 .log(.debug, subsystems: .callKit) { "Will perform SetMutedCallAction with muted:\($0). " }
-                .sinkTask(storeIn: disposableBag) { [weak self] in
-                    do {
-                        try await self?.requestTransaction(CXSetMutedCallAction(call: callUUID, muted: $0))
-                    } catch {
-                        log.warning("Unable to apply CallSettings.audioOn:\(!$0).", subsystems: .callKit)
-                    }
-                }
+                .sink { [weak self] in self?.performCallSettingMuteRequest($0, callUUID: callUUID) }
                 .store(in: disposableBag, key: key)
         }
     }
+
+    private func performCallSettingMuteRequest(
+        _ muted: Bool,
+        callUUID: UUID
+    ) {
+        muteProcessingQueue.addTaskOperation { [weak self] in
+            guard
+                let self,
+                callUUID == active,
+                isMuted != muted
+            else {
+                return
+            }
+            do {
+                try await requestTransaction(CXSetMutedCallAction(call: callUUID, muted: muted))
+                isMuted = muted
+            } catch {
+                log.warning("Unable to apply CallSettings.audioOn:\(!muted).", subsystems: .callKit)
+            }
+        }
+    }
+
+    private func performMuteRequest(_ request: MuteRequest) {
+        muteProcessingQueue.addTaskOperation { [weak self] in
+            guard
+                let self,
+                request.callUUID == active,
+                isMuted != request.isMuted,
+                let stackEntry = callEntry(for: request.callUUID)
+            else {
+                return
+            }
+
+            do {
+                if request.isMuted {
+                    stackEntry.call.didPerform(.performSetMutedCall)
+                    try await stackEntry.call.microphone.disable()
+                } else {
+                    stackEntry.call.didPerform(.performSetMutedCall)
+                    try await stackEntry.call.microphone.enable()
+                }
+                isMuted = request.isMuted
+            } catch {
+                log.error(
+                    "Unable to set call uuid:\(request.callUUID) muted:\(request.isMuted) state.",
+                    error: error
+                )
+            }
+        }
+    }
 }
 
 extension CallKitService: InjectionKey {

Sources/StreamVideo/CallSettings/MicrophoneManager.swift

@@ -12,35 +12,72 @@ public final class MicrophoneManager: ObservableObject, CallSettingsManager, @un
     /// The status of the microphone.
     @Published public internal(set) var status: CallSettingsStatus
     let state = CallSettingsState()
-
+    
     init(callController: CallController, initialStatus: CallSettingsStatus) {
         self.callController = callController
         status = initialStatus
     }
-
+    
     /// Toggles the microphone state.
-    public func toggle() async throws {
-        try await updateAudioStatus(status.next)
+    public func toggle(
+        file: StaticString = #file,
+        function: StaticString = #function,
+        line: UInt = #line
+    ) async throws {
+        try await updateAudioStatus(
+            status.next,
+            file: file,
+            function: function,
+            line: line
+        )
     }
-
+    
     /// Enables the microphone.
-    public func enable() async throws {
-        try await updateAudioStatus(.enabled)
+    public func enable(
+        file: StaticString = #file,
+        function: StaticString = #function,
+        line: UInt = #line
+    ) async throws {
+        try await updateAudioStatus(
+            .enabled,
+            file: file,
+            function: function,
+            line: line
+        )
     }
-
+    
     /// Disables the microphone.
-    public func disable() async throws {
-        try await updateAudioStatus(.disabled)
+    public func disable(
+        file: StaticString = #file,
+        function: StaticString = #function,
+        line: UInt = #line
+    ) async throws {
+        try await updateAudioStatus(
+            .disabled,
+            file: file,
+            function: function,
+            line: line
+        )
     }
 
     // MARK: - private
 
-    private func updateAudioStatus(_ status: CallSettingsStatus) async throws {
+    private func updateAudioStatus(
+        _ status: CallSettingsStatus,
+        file: StaticString = #file,
+        function: StaticString = #function,
+        line: UInt = #line
+    ) async throws {
         try await updateState(
             newState: status.boolValue,
             current: self.status.boolValue,
             action: { [unowned self] state in
-                try await callController.changeAudioState(isEnabled: state)
+                try await callController.changeAudioState(
+                    isEnabled: state,
+                    file: file,
+                    function: function,
+                    line: line
+                )
             },
             onUpdate: { _ in
                 self.status = status

Sources/StreamVideo/CallState.swift

@@ -121,7 +121,7 @@ public class CallState: ObservableObject {
     @Published public internal(set) var anonymousParticipantCount: UInt32 = 0
     @Published public internal(set) var participantCount: UInt32 = 0
     @Published public internal(set) var isInitialized: Bool = false
-    @Published public internal(set) var callSettings = CallSettings()
+    @Published public internal(set) var callSettings: CallSettings = .default
 
     @Published public internal(set) var isCurrentUserScreensharing: Bool = false
     @Published public internal(set) var duration: TimeInterval = 0

Sources/StreamVideo/Controllers/CallController.swift

@@ -152,8 +152,18 @@ class CallController: @unchecked Sendable {
 
     /// Changes the audio state for the current user.
     /// - Parameter isEnabled: whether audio should be enabled.
-    func changeAudioState(isEnabled: Bool) async throws {
-        await webRTCCoordinator.changeAudioState(isEnabled: isEnabled)
+    func changeAudioState(
+        isEnabled: Bool,
+        file: StaticString = #file,
+        function: StaticString = #function,
+        line: UInt = #line
+    ) async throws {
+        await webRTCCoordinator.changeAudioState(
+            isEnabled: isEnabled,
+            file: file,
+            function: function,
+            line: line
+        )
     }
 
     /// Changes the video state for the current user.

Sources/StreamVideo/Models/CallSettings.swift

@@ -7,6 +7,8 @@ import Foundation
 
 /// Represents the settings for a call.
 public final class CallSettings: ObservableObject, Sendable, Equatable, CustomStringConvertible {
+    public static let `default` = CallSettings()
+
     /// Whether the audio is on for the current user.
     public let audioOn: Bool
     /// Whether the video is on for the current user.