Fix AudioManager deadlock (#121)

* Update AudioManager.swift

* simplify

Author: hiroshihorie

Sources/LiveKit/Track/AudioManager.swift

@@ -27,7 +27,9 @@ public class AudioManager: Loggable {
     public typealias ConfigureAudioSessionFunc = (_ newState: State,
                                                   _ oldState: State) -> Void
 
-    public var customConfigureFunc: ConfigureAudioSessionFunc?
+    /// Use this to provide a custom func to configure the audio session instead of ``defaultConfigureAudioSessionFunc(newState:oldState:)``.
+    /// This method should not block and is expected to return immediately.
+    public var customConfigureAudioSessionFunc: ConfigureAudioSessionFunc?
 
     public enum TrackState {
         case none
@@ -59,7 +61,6 @@ public class AudioManager: Loggable {
     // MARK: - Private
 
     private var _state = StateSync(State())
-    private let configureQueue = DispatchQueue(label: "LiveKitSDK.AudioManager.configure", qos: .default)
 
     #if os(iOS)
     private let notificationQueue = OperationQueue()
@@ -93,9 +94,7 @@ public class AudioManager: Loggable {
         // trigger events when state mutates
         _state.onMutate = { [weak self] newState, oldState in
             guard let self = self else { return }
-            self.configureQueue.async {
-                self.configureAudioSession(newState: newState, oldState: oldState)
-            }
+            self.configureAudioSession(newState: newState, oldState: oldState)
         }
     }
 
@@ -124,106 +123,96 @@ public class AudioManager: Loggable {
         }
     }
 
-    private func configureAudioSession(newState: State,
-                                       oldState: State) {
+    private func configureAudioSession(newState: State, oldState: State) {
+
         log("\(oldState) -> \(newState)")
 
         #if os(iOS)
         if let _deprecatedFunc = LiveKit.onShouldConfigureAudioSession {
             _deprecatedFunc(newState.trackState, oldState.trackState)
-        } else if let customConfigureFunc = customConfigureFunc {
-            customConfigureFunc(newState, oldState)
+        } else if let customConfigureAudioSessionFunc = customConfigureAudioSessionFunc {
+            customConfigureAudioSessionFunc(newState, oldState)
         } else {
-            defaultShouldConfigureAudioSessionFunc(newState: newState,
-                                                   oldState: oldState)
+            defaultConfigureAudioSessionFunc(newState: newState, oldState: oldState)
         }
         #endif
     }
 
     #if os(iOS)
+    /// The default implementation when audio session configuration is requested by the SDK.
     /// Configure the `RTCAudioSession` of `WebRTC` framework.
     ///
     /// > Note: It is recommended to use `RTCAudioSessionConfiguration.webRTC()` to obtain an instance of `RTCAudioSessionConfiguration` instead of instantiating directly.
     ///
-    /// View ``defaultShouldConfigureAudioSessionFunc(newState:oldState:)`` for usage of this method.
-    ///
     /// - Parameters:
     ///   - configuration: A configured RTCAudioSessionConfiguration
     ///   - setActive: passing true/false will call `AVAudioSession.setActive` internally
-    public func configureAudioSession(_ configuration: RTCAudioSessionConfiguration,
-                                      setActive: Bool? = nil,
-                                      preferSpeakerOutput: Bool = true) {
-
-        let session: RTCAudioSession = DispatchQueue.webRTC.sync {
-            let result = RTCAudioSession.sharedInstance()
-            result.lockForConfiguration()
-            return result
-        }
+    public func defaultConfigureAudioSessionFunc(newState: State, oldState: State) {
 
-        defer { DispatchQueue.webRTC.sync { session.unlockForConfiguration() } }
+        DispatchQueue.webRTC.async { [weak self] in
 
-        do {
-            logger.log("configuring audio session with category: \(configuration.category), mode: \(configuration.mode), setActive: \(String(describing: setActive))", type: AudioManager.self)
+            guard let self = self else { return }
 
-            if let setActive = setActive {
-                try DispatchQueue.webRTC.sync { try session.setConfiguration(configuration, active: setActive) }
-            } else {
-                try DispatchQueue.webRTC.sync { try session.setConfiguration(configuration) }
-            }
+            // prepare config
+            let configuration = RTCAudioSessionConfiguration.webRTC()
+            var categoryOptions: AVAudioSession.CategoryOptions = []
 
-        } catch let error {
-            logger.log("Failed to configureAudioSession with error: \(error)", .error, type: AudioManager.self)
-        }
+            switch newState.trackState {
+            case .remoteOnly:
+                configuration.category = AVAudioSession.Category.playback.rawValue
+                configuration.mode = AVAudioSession.Mode.spokenAudio.rawValue
+            case  .localOnly, .localAndRemote:
+                configuration.category = AVAudioSession.Category.playAndRecord.rawValue
+                configuration.mode = AVAudioSession.Mode.videoChat.rawValue
 
-        do {
-            logger.log("preferSpeakerOutput: \(preferSpeakerOutput)", type: AudioManager.self)
-            try DispatchQueue.webRTC.sync { try session.overrideOutputAudioPort(preferSpeakerOutput ? .speaker : .none) }
-        } catch let error {
-            logger.log("Failed to overrideOutputAudioPort with error: \(error)", .error, type: AudioManager.self)
-        }
-    }
+                categoryOptions = [.allowBluetooth, .allowBluetoothA2DP]
 
-    /// The default implementation when audio session configuration is requested by the SDK.
-    public func defaultShouldConfigureAudioSessionFunc(newState: State,
-                                                       oldState: State) {
+                if newState.preferSpeakerOutput {
+                    categoryOptions.insert(.defaultToSpeaker)
+                }
 
-        let config = DispatchQueue.webRTC.sync { RTCAudioSessionConfiguration.webRTC() }
+            default:
+                configuration.category = AVAudioSession.Category.soloAmbient.rawValue
+                configuration.mode = AVAudioSession.Mode.default.rawValue
+            }
 
-        var categoryOptions: AVAudioSession.CategoryOptions = []
+            configuration.categoryOptions = categoryOptions
 
-        switch newState.trackState {
-        case .remoteOnly:
-            config.category = AVAudioSession.Category.playback.rawValue
-            config.mode = AVAudioSession.Mode.spokenAudio.rawValue
-        case  .localOnly, .localAndRemote:
-            config.category = AVAudioSession.Category.playAndRecord.rawValue
-            config.mode = AVAudioSession.Mode.videoChat.rawValue
+            var setActive: Bool?
+            if newState.trackState != .none, oldState.trackState == .none {
+                // activate audio session when there is any local/remote audio track
+                setActive = true
+            } else if newState.trackState == .none, oldState.trackState != .none {
+                // deactivate audio session when there are no more local/remote audio tracks
+                setActive = false
+            }
 
-            categoryOptions = [.allowBluetooth, .allowBluetoothA2DP]
+            // configure session
+            let session = RTCAudioSession.sharedInstance()
+            session.lockForConfiguration()
+            // always unlock
+            defer { session.unlockForConfiguration() }
 
-            if newState.preferSpeakerOutput {
-                categoryOptions.insert(.defaultToSpeaker)
-            }
+            do {
+                self.log("configuring audio session with category: \(configuration.category), mode: \(configuration.mode), setActive: \(String(describing: setActive))")
 
-        default:
-            config.category = AVAudioSession.Category.soloAmbient.rawValue
-            config.mode = AVAudioSession.Mode.default.rawValue
-        }
+                if let setActive = setActive {
+                    try session.setConfiguration(configuration, active: setActive)
+                } else {
+                    try session.setConfiguration(configuration)
+                }
 
-        config.categoryOptions = categoryOptions
+            } catch let error {
+                self.log("Failed to configureAudioSession with error: \(error)", .error)
+            }
 
-        var setActive: Bool?
-        if newState.trackState != .none, oldState.trackState == .none {
-            // activate audio session when there is any local/remote audio track
-            setActive = true
-        } else if newState.trackState == .none, oldState.trackState != .none {
-            // deactivate audio session when there are no more local/remote audio tracks
-            setActive = false
+            do {
+                self.log("preferSpeakerOutput: \(newState.preferSpeakerOutput)")
+                try session.overrideOutputAudioPort(newState.preferSpeakerOutput ? .speaker : .none)
+            } catch let error {
+                self.log("Failed to overrideOutputAudioPort with error: \(error)", .error)
+            }
         }
-
-        configureAudioSession(config,
-                              setActive: setActive,
-                              preferSpeakerOutput: newState.preferSpeakerOutput)
     }
     #endif
 }