Change Audio input programmatically doesn't change Audio engine input AVFoundation

I'm trying to change the audio input (microphone) between all the available devices from AVAudioSession.sharedInstance().availableInputs. I'm using AVAudioSession.routeChangeNotification to get automatic route changes when devices get connected/disconnected and change the preferred input with setPreferredInput, then I restart my audioEngine and it works fine.

But when I try to change the preferred input programmatically It doesn't change the audio capture inputNode. But keeps the last connected device and capturing.

Even the AVAudioSession.sharedInstance().currentRoute.inputs changes but the audioEngine?.inputNode doesn't change to setPreferredInput call.

WhatsApp seems to have done that without any issues.

Any suggestions or leads are highly appreciated. Thanks.

These are some related code segments. enableMic programmatically is the issue.

    private var audioEngine: AVAudioEngine?
    private var inputNode: AVAudioNode!

    private func setupAudioSession() {
        do {
            let session = AVAudioSession.sharedInstance()
            try session.setCategory(.playAndRecord, options: [.defaultToSpeaker, .allowBluetooth])
            try session.setActive(true)
        } catch {
            print(error)
        }
    }

    func setupAudioEngine() {
        audioEngine?.stop()
        audioEngine?.reset()

        setupAudioSession()

        audioEngine = AVAudioEngine()
        inputNode = audioEngine?.inputNode

        guard let hardwareSampleRate = audioEngine?.inputNode.inputFormat(forBus: 0).sampleRate else { return }

        let format = AVAudioFormat(standardFormatWithSampleRate: hardwareSampleRate, channels: 1)

        let requiredBufferSize: AVAudioFrameCount = 4800

        inputNode.installTap(onBus: 0,
                             bufferSize: requiredBufferSize,
                             format: format
        ) { [self] (buffer: AVAudioPCMBuffer, _: AVAudioTime) in
            // process the buffer
        }

        audioEngine?.prepare()
    }

    func startRecording() {
        do {
            try audioEngine?.start()
        } catch {
            print("Could not start audioEngine: \(error)")
        }
    }

    private func observeRouteChanges() {
        NotificationCenter.default.addObserver(self,
                                               selector: #selector(handleRouteChange),
                                               name: AVAudioSession.routeChangeNotification,
                                               object: nil)
    }

    @objc func handleRouteChange(notification: Notification) {
        guard let userInfo = notification.userInfo,
              let reasonValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
              let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue) else {
            return
        }

        switch reason {

        case .newDeviceAvailable, .oldDeviceUnavailable:
            // enableMic with current route AVAudioSession.sharedInstance().currentRoute.inputs.first

        default: ()
        }

    }

    private func enableMic(mic: AVAudioSessionPortDescription?) {
        let session = AVAudioSession.sharedInstance()
        do {
            try session.setPreferredInput(mic)
            // re-setup the audio engine and start
        } catch {
            print(error)
        }
    }

Also new to AVFoundation. For your question

Change Audio input programmatically doesn't change Audio engine input AVFoundation? Yes, it does not change the inputNode property even if you programmatically change the input device.

Please take at Apple's documentation on this property:

The inputNode does not change. That's expected. The inputNode property of AVAudioEngine is a computed property, and it is evaluated lazily(on demand) when it is first accessed.

When you access the inputNode property for the first time, the AVAudioEngine creates a singleton instance of the AVAudioInputNode class – using the AVAudioEngine's default AVAudioNode render format – to represent the hardware's audio input connection. This instance handles audio input in the audio engine's processing graph, and the audio input format is automatically determined by the properties of your audio hardware.

Once the node is created, subsequent calls to input node will return the same instance.

And to prove that I wrote a demo app, I think you have tried it. Take a look at this method, which is used to start tapping input node:

public func startMonitoring(){
    /* with out this code, installTap will crash due to 'required condition is false: format.sampleRate == hwFormat.sampleRate' install tap
    audioEngine = AVAudioEngine()
    */
    let inputNode = audioEngine.inputNode
    let inputFormat = inputNode.outputFormat(forBus: 0)
    // Install a tap on the audio engine with the buffer size and the input format.
    debugPrint("inputFormat:",inputFormat)
    audioEngine.inputNode.installTap(onBus: 0, bufferSize: AVAudioFrameCount(bufferSize), format: inputFormat) { buffer, _ in
      self.audioMetering(buffer: buffer)
    }
    audioEngine.prepare()
    do {
      try audioEngine.start()
    } catch {
      debugPrint("\(error.localizedDescription)")
    }
  }

If you try to call this method after the AVAudioEngineConfigurationChange notification, you will find the app crashes at audioEngine.inputNode.installTap(onBus:, bufferSize:,format:), especially when you are switching between AirPods and built-in microphone. That's because the inputNode does not update when the input device is physically changed. Just like the documentation says, 'it is created on demand when first accessed'.

I hope that clarifies how the lazy instantiation works for the inputNode property of AVAudioEngine. Let me know if you have any further questions.

BTW, here is the demo repo link. The demo both have automatic audio input switching and manual audio input switch.