Fix audio processing delegate lifecycle

Sources/LiveKit/Audio/Manager/AudioManager.swift

@@ -101,10 +101,10 @@
         // Keep this var within State so it's protected by UnfairLock
         public var localTracksCount: Int = 0
         public var remoteTracksCount: Int = 0
         public var customConfigureFunc: ConfigureAudioSessionFunc?
         public var sessionConfiguration: AudioSessionConfiguration?
 
         public var trackState: TrackState {
             switch (localTracksCount > 0, remoteTracksCount > 0) {
             case (true, false): .localOnly
             case (false, true): .remoteOnly
@@ -117,28 +117,29 @@
 
     // MARK: - AudioProcessingModule
 
-    private lazy var capturePostProcessingDelegateAdapter: AudioCustomProcessingDelegateAdapter = {
-        let adapter = AudioCustomProcessingDelegateAdapter(label: "capturePost")
-        RTC.audioProcessingModule.capturePostProcessingDelegate = adapter
-        return adapter
-    }()
-
-    private lazy var renderPreProcessingDelegateAdapter: AudioCustomProcessingDelegateAdapter = {
-        let adapter = AudioCustomProcessingDelegateAdapter(label: "renderPre")
-        RTC.audioProcessingModule.renderPreProcessingDelegate = adapter
-        return adapter
-    }()
+    private lazy var capturePostProcessingDelegateAdapter = AudioCustomProcessingDelegateAdapter(label: "capturePost")
+
+    private lazy var renderPreProcessingDelegateAdapter = AudioCustomProcessingDelegateAdapter(label: "renderPre")
 
     let capturePostProcessingDelegateSubject = CurrentValueSubject<AudioCustomProcessingDelegate?, Never>(nil)
 
     /// Add a delegate to modify the local audio buffer before it is sent to the network
     /// - Note: Only one delegate can be set at a time, but you can create one to wrap others if needed
     /// - Note: If you only need to observe the buffer (rather than modify it), use ``add(localAudioRenderer:)`` instead
     public var capturePostProcessingDelegate: AudioCustomProcessingDelegate? {
-        get { capturePostProcessingDelegateAdapter.target }
-        set {
-            capturePostProcessingDelegateAdapter.set(target: newValue)
-            capturePostProcessingDelegateSubject.send(newValue)
+        didSet {
+            if let capturePostProcessingDelegate {
+                //
+                RTC.audioProcessingModule.capturePostProcessingDelegate = nil
+                capturePostProcessingDelegateAdapter.set(target: nil)
+                //
+                capturePostProcessingDelegateAdapter.set(target: capturePostProcessingDelegate)
+                RTC.audioProcessingModule.capturePostProcessingDelegate = capturePostProcessingDelegateAdapter
+            } else {
+                RTC.audioProcessingModule.capturePostProcessingDelegate = nil
+                capturePostProcessingDelegateAdapter.set(target: nil)
+            }
+            capturePostProcessingDelegateSubject.send(capturePostProcessingDelegate)
         }
     }
 
@@ -147,8 +148,19 @@
     /// - Note: If you only need to observe the buffer (rather than modify it), use ``add(remoteAudioRenderer:)`` instead
     /// - Note: If you need to observe the buffer for individual tracks, use ``RemoteAudioTrack/add(audioRenderer:)`` instead
     public var renderPreProcessingDelegate: AudioCustomProcessingDelegate? {
-        get { renderPreProcessingDelegateAdapter.target }
-        set { renderPreProcessingDelegateAdapter.set(target: newValue) }
+        didSet {
+            if let renderPreProcessingDelegate {
+                //
+                RTC.audioProcessingModule.renderPreProcessingDelegate = nil
+                renderPreProcessingDelegateAdapter.set(target: nil)
+                //
+                renderPreProcessingDelegateAdapter.set(target: renderPreProcessingDelegate)
+                RTC.audioProcessingModule.renderPreProcessingDelegate = renderPreProcessingDelegateAdapter
+            } else {
+                RTC.audioProcessingModule.renderPreProcessingDelegate = nil
+                renderPreProcessingDelegateAdapter.set(target: nil)
+            }
+        }
     }
 
     // MARK: - AudioDeviceModule

Sources/LiveKit/Protocols/AudioCustomProcessingDelegate.swift

@@ -52,7 +52,7 @@ class AudioCustomProcessingDelegateAdapter: MulticastDelegate<AudioRenderer>, @u
     // MARK: - Private
 
     private struct State {
-        weak var target: AudioCustomProcessingDelegate?
+        var target: AudioCustomProcessingDelegate?
     }
 
     private var _state = StateSync(State())

Tests/LiveKitAudioTests/AudioProcessingLifecycle.swift

@@ -0,0 +1,108 @@
+/*
+ * 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.
+ */
+
+import Accelerate
+import AVFoundation
+import Foundation
+import LiveKitWebRTC
+
+@testable import LiveKit
+import LiveKitTestSupport
+import XCTest
+
+private enum CallType {
+    case initialize
+    case process
+    case release
+}
+
+private class ProcessingDelegateTester: AudioCustomProcessingDelegate, @unchecked Sendable {
+    let label: String
+    struct State {
+        var entries: [CallType] = []
+    }
+
+    let _state = StateSync(State())
+
+    init(label: String) {
+        self.label = label
+    }
+
+    func audioProcessingInitialize(sampleRate sampleRateHz: Int, channels: Int) {
+        _state.mutate { $0.entries.append(.initialize) }
+        print("ProcessingDelegate(\(label)).Initialize(sampleRate: \(sampleRateHz), channels: \(channels))")
+    }
+
+    func audioProcessingProcess(audioBuffer: LiveKit.LKAudioBuffer) {
+        _state.mutate { $0.entries.append(.process) }
+        print("ProcessingDelegate(\(label)).Process(audioBuffer: \(audioBuffer.frames))")
+    }
+
+    func audioProcessingRelease() {
+        _state.mutate { $0.entries.append(.release) }
+        print("ProcessingDelegate(\(label)).Release")
+    }
+}
+
+class AudioProcessingLifecycle: LKTestCase {
+    func testAudioProcessing() async throws {
+        let processorA = ProcessingDelegateTester(label: "A")
+        let processorB = ProcessingDelegateTester(label: "B")
+        // Set processing delegate
+        AudioManager.shared.capturePostProcessingDelegate = processorA
+
+        try await withRooms([RoomTestingOptions(canPublish: true)]) { rooms in
+            // Alias to Room1
+            let room1 = rooms[0]
+            // Publish mic
+            try await room1.localParticipant.setMicrophone(enabled: true)
+            do {
+                // 1 secs...
+                let ns = UInt64(1 * 1_000_000_000)
+                try await Task.sleep(nanoseconds: ns)
+            }
+
+            // Verify processorA was initialized and received audio
+            let stateA = processorA._state.copy()
+            XCTAssertTrue(stateA.entries.contains(.initialize), "Processor A should have been initialized")
+            XCTAssertTrue(stateA.entries.contains(.process), "Processor A should have processed audio")
+
+            // Switch to processorB
+            AudioManager.shared.capturePostProcessingDelegate = processorB
+            do {
+                // 1 secs...
+                let ns = UInt64(1 * 1_000_000_000)
+                try await Task.sleep(nanoseconds: ns)
+            }
+
+            // Verify processorA was released
+            let stateA2 = processorA._state.copy()
+            XCTAssertTrue(stateA2.entries.contains(.release), "Processor A should have been released")
+
+            // Verify processorB was initialized and received audio
+            let stateB = processorB._state.copy()
+            XCTAssertTrue(stateB.entries.contains(.initialize), "Processor B should have been initialized")
+            XCTAssertTrue(stateB.entries.contains(.process), "Processor B should have processed audio")
+        }
+
+        // Remove processing delegate
+        AudioManager.shared.capturePostProcessingDelegate = nil
+
+        // Verify processorB was released
+        let stateB2 = processorB._state.copy()
+        XCTAssertTrue(stateB2.entries.contains(.release), "Processor B should have been released")
+    }
+}