why audio play stops when connecting to an bluetooth device (e.g. airpods)

My speaker class would receives real-time streaming audio chunk from our backend (PCM, 16bit int, 48k sample rate, 1 channel, 20ms duration) and the client is supposed to play the audios.
Therefore, I created this class Speaker that uses AVAudioEngine to play.

import AVFoundation

class Speaker {
    // Attributes
    private var audioQueue: [AVAudioPCMBuffer]
    private let audioEngine: AVAudioEngine
    private let audioPlayerNode: AVAudioPlayerNode
    private var isPlaying: Bool
    // format from backend
    private let srcFormat: AVAudioFormat
    // format for speaker
    private let tgtFormat: AVAudioFormat
    
    private let processQueue = DispatchQueue(label: "processQueue")
    private let playQueue = DispatchQueue(label: "playQueue")

    // Initializer
    init(sampleRate: Double = 48000.0) throws {
        self.audioQueue = []
        self.audioEngine = AVAudioEngine()
        self.audioPlayerNode = AVAudioPlayerNode()
        self.isPlaying = false

        self.srcFormat = AVAudioFormat(
            commonFormat: .pcmFormatInt16,
            sampleRate: sampleRate,
            channels: 1,
            interleaved: false
        )!
        self.tgtFormat = AVAudioFormat(
            // ios only supports input format of .pcmFormatFloat32
            commonFormat: .pcmFormatFloat32,
            sampleRate: sampleRate,
            channels: 1,
            interleaved: false
        )!
        
        do {
            try configureAudioEngine()
        } catch {
            // report error to js
            // potentiallly report to sentry and record the device type
        }
        NSLog("configuartion is done")
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleRouteChange(_:)),
            name: AVAudioSession.routeChangeNotification,
            object: nil
        )
    }
    
    private func configureAudioEngine() throws {
        NSLog("create pipeline")
        self.audioEngine.attach(self.audioPlayerNode)
        self.audioEngine.connect(
            self.audioPlayerNode,
            to: self.audioEngine.mainMixerNode,
            format: tgtFormat
        )
        NSLog("pipeline created")

        NSLog("starting engine")
        try self.audioEngine.start()
        NSLog("engine started")
    }
    
    deinit {
        NotificationCenter.default.removeObserver(
            self, name: AVAudioSession.routeChangeNotification, object: nil
        )
    }

    func play() {
        guard !isPlaying else { return }
        isPlaying = true
        audioPlayerNode.play()
        playNextBuffer()
    }

    func push(audioChunk: Data) {
        processQueue.async {
            guard let buffer = self.createPCMBuffer(from: audioChunk) else {
                NSLog("failed to create buffer from chunk")
                return 
            }
            NSLog("pushing chunk to queue, size: (buffer.frameLength)")
            self.audioQueue.append(buffer)
            NSLog("pushed one chunk to queue")
            if self.isPlaying {
                self.playNextBuffer()
            }
        }
    }

    func stop() {
        isPlaying = false
        audioPlayerNode.stop()
        audioEngine.stop()
        audioQueue.removeAll()
        self.audioQueue = [] // clear the queue
    }

    private func playNextBuffer() {
        playQueue.async {
            guard self.isPlaying, self.audioPlayerNode.isPlaying, let buffer = self.audioQueue.first else {
                NSLog("no buffer to play or the player is not playing, exiting...")
                return
            }
            self.audioQueue.removeFirst()
            NSLog("schedule to play buffer, size: (buffer.frameLength)")
            self.audioPlayerNode.scheduleBuffer(buffer, completionHandler: self.playNextBuffer)
        }
    }

    @objc private 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:
            NSLog("New device available")
            if self.isPlaying {
                self.audioPlayerNode.pause()

                if !self.audioEngine.isRunning {
                    self.audioEngine.start()
                }

                if !self.audioPlayerNode.isPlaying {
                    self.audioPlayerNode.play()
            }
        case .oldDeviceUnavailable:
            NSLog("Old device unavailable")
            if let previousRoute = userInfo[AVAudioSessionRouteChangePreviousRouteKey] as? AVAudioSessionRouteDescription {
                for output in previousRoute.outputs {
                    if output.portType == .bluetoothA2DP || output.portType == .bluetoothLE || output.portType == .bluetoothHFP {
                        NSLog("Bluetooth device disconnected")
                        if isPlaying {
                            audioPlayerNode.pause()
                            audioPlayerNode.play()
                        }
                    }
                }
            }
        default:
            break
        }
    }

    func createPCMBuffer(from data: Data) -> AVAudioPCMBuffer? {
        // Create the source buffer
        let int16Array = data.withUnsafeBytes {
            Array(UnsafeBufferPointer<Int16>(
                    start: $0.bindMemory(to: Int16.self).baseAddress!,
                    count: data.count / MemoryLayout<Int16>.size
                )
            )
        }
        
        // Create an AVAudioPCMBuffer from the Int16 array
        let frameCapacity = UInt32(int16Array.count)
        guard let srcBuffer = AVAudioPCMBuffer(
            pcmFormat: srcFormat, frameCapacity: frameCapacity
        ) else {
            NSLog("srcBuffer is nil")
            return nil
        }
        srcBuffer.frameLength = frameCapacity
        
        // Copy data into the source buffer
        int16Array.withUnsafeBufferPointer { int16Pointer in
            memcpy(srcBuffer.int16ChannelData![0], int16Pointer.baseAddress!, Int(frameCapacity) * MemoryLayout<Int16>.size)
        }
        
        // Create the target buffer
        guard let tgtBuffer = AVAudioPCMBuffer(
            pcmFormat: tgtFormat, frameCapacity: frameCapacity
        ) else {
            NSLog("destinationBuffer is nil")
            return nil
        }

        // Create the AVAudioConverter
        let converter = AVAudioConverter(from: srcFormat, to: tgtFormat)
        
        do {
            // Perform the conversion
            try converter?.convert(to: tgtBuffer, from: srcBuffer)
        } catch {
            NSLog("Conversion error: (error)")
            return nil
        }

        return tgtBuffer
    }
}

According to the official doc, when plug in a new external audio device like airpods shouldn’t pause the audio but instead, direct the audio to that device.
However, in my case, it would stop to play the audio right after it connects to an airpods.

Note,

before, the code didn’t do anything when new device is available in the notification handler, but later I tested and found out the AudioEngine was turned off. Therefore I add the code there to restart the AudioEngine and Player Node.
Our backend uses websocket to communicate and therefore I didn’t use the webRTC framework in the first place.

The App is supposed to keep playing audio when it connect to a bluetooth audio device.

I tried to add a reset function when new device is connected, but that doesn’t help.

New contributor

Filed under: Kiến thức lập trình - @ 05:01

Thẻ: iosswiftaudiostreaming

Thiết kế website giá rẻ

Danh mục

why audio play stops when connecting to an bluetooth device (e.g. airpods)