Legacy mic mute mode

Package.swift

@@ -18,7 +18,7 @@ let package = Package(
     ],
     dependencies: [
         // LK-Prefixed Dynamic WebRTC XCFramework
-        .package(url: "https://github.com/livekit/webrtc-xcframework.git", exact: "125.6422.17"),
+        .package(url: "https://github.com/livekit/webrtc-xcframework.git", exact: "125.6422.18"),
         .package(url: "https://github.com/apple/swift-protobuf.git", from: "1.26.0"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.5.4"),
         // Only used for DocC generation

Package@swift-5.9.swift

@@ -20,7 +20,7 @@ let package = Package(
     ],
     dependencies: [
         // LK-Prefixed Dynamic WebRTC XCFramework
-        .package(url: "https://github.com/livekit/webrtc-xcframework.git", exact: "125.6422.17"),
+        .package(url: "https://github.com/livekit/webrtc-xcframework.git", exact: "125.6422.18"),
         .package(url: "https://github.com/apple/swift-protobuf.git", from: "1.26.0"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.5.4"),
         // Only used for DocC generation

Sources/LiveKit/Track/AudioManager.swift

@@ -101,10 +101,10 @@
         public var localTracksCount: Int = 0
         public var remoteTracksCount: Int = 0
         public var isSpeakerOutputPreferred: Bool = true
         public var customConfigureFunc: ConfigureAudioSessionFunc?
         public var sessionConfiguration: AudioSessionConfiguration?
 
         public var trackState: TrackState {
             switch (localTracksCount > 0, remoteTracksCount > 0) {
             case (true, false): return .localOnly
             case (false, true): return .remoteOnly
@@ -258,8 +258,33 @@
         _state.mutate { $0.engineObservers = engineObservers }
     }
 
+    /// Set to `true` to enable legacy mic mute mode.
+    ///
+    /// - Default: Uses `AVAudioEngine`'s `isVoiceProcessingInputMuted` internally.
+    ///   This is fast, and muted speaker detection works. However, iOS will play a sound effect.
+    /// - Legacy: Restarts the internal `AVAudioEngine` without mic input when muted.
+    ///   This is slower, and muted speaker detection does not work. No sound effect is played.
+    public var isLegacyMuteMode: Bool {
+        get { RTC.audioDeviceModule.muteMode == .restartEngine }
+        set { RTC.audioDeviceModule.muteMode = newValue ? .restartEngine : .voiceProcessing }
+    }
+
     // MARK: - For testing
 
+    var isEngineRunning: Bool {
+        RTC.audioDeviceModule.isEngineRunning
+    }
+
+    var isMicrophoneMuted: Bool {
+        get { RTC.audioDeviceModule.isMicrophoneMuted }
+        set { RTC.audioDeviceModule.isMicrophoneMuted = newValue }
+    }
+
+    var engineState: RTCAudioEngineState {
+        get { RTC.audioDeviceModule.engineState }
+        set { RTC.audioDeviceModule.engineState = newValue }
+    }
+
     var isPlayoutInitialized: Bool {
         RTC.audioDeviceModule.isPlayoutInitialized
     }

Tests/LiveKitTests/MuteTests.swift

@@ -0,0 +1,174 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@testable import LiveKit
+import LiveKitWebRTC
+import XCTest
+
+struct TestEngineTransition {
+    let outputEnabled: ValueOrAbsent<Bool>
+    let outputRunning: ValueOrAbsent<Bool>
+    let inputEnabled: ValueOrAbsent<Bool>
+    let inputRunning: ValueOrAbsent<Bool>
+    let legacyMuteMode: ValueOrAbsent<Bool>
+    let inputMuted: ValueOrAbsent<Bool>
+
+    init(outputEnabled: ValueOrAbsent<Bool> = .absent,
+         outputRunning: ValueOrAbsent<Bool> = .absent,
+         inputEnabled: ValueOrAbsent<Bool> = .absent,
+         inputRunning: ValueOrAbsent<Bool> = .absent,
+         legacyMuteMode: ValueOrAbsent<Bool> = .absent,
+         inputMuted: ValueOrAbsent<Bool> = .absent)
+    {
+        self.outputEnabled = outputEnabled
+        self.outputRunning = outputRunning
+        self.inputEnabled = inputEnabled
+        self.inputRunning = inputRunning
+        self.legacyMuteMode = legacyMuteMode
+        self.inputMuted = inputMuted
+    }
+}
+
+struct TestEngineAssert: Hashable {
+    let engineRunning: Bool
+}
+
+struct TestEngineStep {
+    let transition: TestEngineTransition
+    let assert: TestEngineAssert
+}
+
+extension RTCAudioEngineState: CustomStringConvertible {
+    public var description: String {
+        "EngineState(" +
+            "outputEnabled: \(outputEnabled), " +
+            "outputRunning: \(outputRunning), " +
+            "inputEnabled: \(inputEnabled), " +
+            "inputRunning: \(inputRunning), " +
+            "inputMuted: \(inputMuted), " +
+            "muteMode: \(muteMode)" +
+            ")"
+    }
+}
+
+func applyEngineTransition(_ transition: TestEngineTransition) {
+    let adm = AudioManager.shared
+    var engineState = adm.engineState
+
+    if case let .value(value) = transition.outputEnabled {
+        engineState.outputEnabled = value
+    }
+
+    if case let .value(value) = transition.outputRunning {
+        engineState.outputRunning = value
+    }
+
+    if case let .value(value) = transition.inputEnabled {
+        engineState.inputEnabled = value
+    }
+
+    if case let .value(value) = transition.inputRunning {
+        engineState.inputRunning = value
+    }
+
+    if case let .value(value) = transition.inputMuted {
+        engineState.inputMuted = value
+    }
+
+    if case let .value(value) = transition.legacyMuteMode {
+        engineState.muteMode = value ? .restartEngine : .voiceProcessing
+    }
+
+    print("Testing engine state: \(engineState)")
+    adm.engineState = engineState
+}
+
+let standardEngineSteps: [TestEngineStep] = [
+    // Enable output
+    TestEngineStep(transition: .init(outputEnabled: .value(true)), assert: .init(engineRunning: false)),
+    TestEngineStep(transition: .init(outputRunning: .value(true)), assert: .init(engineRunning: true)),
+    // Enable input
+    TestEngineStep(transition: .init(inputEnabled: .value(true)), assert: .init(engineRunning: true)),
+    TestEngineStep(transition: .init(inputRunning: .value(true)), assert: .init(engineRunning: true)),
+    // Disable input
+    TestEngineStep(transition: .init(inputRunning: .value(false)), assert: .init(engineRunning: true)),
+    TestEngineStep(transition: .init(inputEnabled: .value(false)), assert: .init(engineRunning: true)),
+    // Disable output
+    TestEngineStep(transition: .init(outputRunning: .value(false)), assert: .init(engineRunning: false)),
+    TestEngineStep(transition: .init(outputEnabled: .value(false)), assert: .init(engineRunning: false)),
+]
+
+let muteEngineSteps: [TestEngineStep] = [
+    // Enable output
+    TestEngineStep(transition: .init(outputEnabled: .value(true)), assert: .init(engineRunning: false)),
+    TestEngineStep(transition: .init(outputRunning: .value(true)), assert: .init(engineRunning: true)),
+
+    // Enable input
+    TestEngineStep(transition: .init(inputEnabled: .value(true)), assert: .init(engineRunning: true)),
+    TestEngineStep(transition: .init(inputRunning: .value(true)), assert: .init(engineRunning: true)),
+
+    // Toggle mute
+    TestEngineStep(transition: .init(inputMuted: .value(true)), assert: .init(engineRunning: true)),
+    TestEngineStep(transition: .init(inputMuted: .value(false)), assert: .init(engineRunning: true)),
+
+    // Enable legacy mute mode
+    TestEngineStep(transition: .init(legacyMuteMode: .value(true)), assert: .init(engineRunning: true)),
+
+    // Disable output
+    TestEngineStep(transition: .init(outputRunning: .value(false)), assert: .init(engineRunning: true)),
+    TestEngineStep(transition: .init(outputEnabled: .value(false)), assert: .init(engineRunning: true)),
+
+    // Engine should shut down at this point
+    TestEngineStep(transition: .init(inputMuted: .value(true)), assert: .init(engineRunning: false)),
+
+    // Engine starts
+    TestEngineStep(transition: .init(inputMuted: .value(false)), assert: .init(engineRunning: true)),
+
+    // Enable output
+    TestEngineStep(transition: .init(outputEnabled: .value(true)), assert: .init(engineRunning: true)),
+    TestEngineStep(transition: .init(outputRunning: .value(true)), assert: .init(engineRunning: true)),
+
+    // Mute
+    TestEngineStep(transition: .init(inputMuted: .value(true)), assert: .init(engineRunning: true)),
+
+    // Disable input
+    TestEngineStep(transition: .init(inputRunning: .value(false)), assert: .init(engineRunning: true)),
+    TestEngineStep(transition: .init(inputEnabled: .value(false)), assert: .init(engineRunning: true)),
+
+    // Disable output
+    TestEngineStep(transition: .init(outputRunning: .value(false)), assert: .init(engineRunning: false)),
+    TestEngineStep(transition: .init(outputEnabled: .value(false)), assert: .init(engineRunning: false)),
+]
+
+class MuteTests: XCTestCase {
+    override func setUp() {
+        super.setUp()
+        continueAfterFailure = false
+    }
+
+    func testTransitions() async throws {
+        let adm = AudioManager.shared
+
+        for step in muteEngineSteps {
+            applyEngineTransition(step.transition)
+            // Check if engine running state is correct.
+            XCTAssert(adm.isEngineRunning == step.assert.engineRunning)
+
+            let ns = UInt64(1 * 1_000_000_000)
+            try await Task.sleep(nanoseconds: ns)
+        }
+    }
+}

Tests/LiveKitTests/Support/AudioRecorder.swift

@@ -23,7 +23,7 @@ class AudioRecorder {
     public let filePath: URL
     private var audioFile: AVAudioFile?
 
-    init(sampleRate: Double = 16000, channels: Int = 1) throws {
+    init(sampleRate: Double = 48000, channels: Int = 1) throws {
         self.sampleRate = sampleRate
 
         let settings: [String: Any] = [