Audio interruption handling background

[lanshanzhao]

Dear developer,when i add an Audio interruption handling in background use use like this code ,but when i interruption and background to the app,the audio cound not resume play again? could you write a demo into the sample app? Thank you

import Accelerate
import AVFoundation
import Combine
import MediaPlayer
import SFBAudioEngine
import SwiftUI

class PlayerViewModel: NSObject, ObservableObject {
    let musicDataViewModel: MusicDataViewModel
    var cancellables = Set<AnyCancellable>()
    private var sleepTimer: Timer?
    private var sleepDuration: TimeInterval = 0
    private var shouldPauseOnDisconnect: Bool
    private var shouldEnableGaplessPlayback: Bool
    private var enableDoP: Bool

    @Published var tracks: [Track] = []
    @Published var nowPlaying: Track? = nil
    @Published var playbackState: AudioPlayer.PlaybackState = .stopped
    @Published var playbackMode: PlaybackMode = .repeatAll
    @Published var isShuffleEnabled: Bool = false
    @Published var playbackMemoryMode: PlaybackMemoryMode = .trackMemory
    @Published var countdownText: String = "未设置"
    private let displayLinkPublisher = DisplayLinkPublisher()
    private var playedTracks: Set<UUID> = []

    let player = AudioPlayer()
    let fftAnalyzer = FftAnalyzer()
    var equalizer: AVAudioUnitEQ!
    var reverb: AVAudioUnitReverb!

    private lazy var nowPlayingSubject = CurrentValueSubject<Track?, Never>(nil)
    private lazy var playbackStateSubject = CurrentValueSubject<AudioPlayer.PlaybackState, Never>(.stopped)
    private lazy var playbackTimeSubject = PassthroughSubject<AudioPlayer.PlaybackTime, Never>()
    var playbackTime: AnyPublisher<AudioPlayer.PlaybackTime, Never> {
        playbackTimeSubject
            .eraseToAnyPublisher()
    }

    override init() {
        musicDataViewModel = MusicDataViewModel.shared
        shouldPauseOnDisconnect = UserDefaults.standard.bool(forKey: "shouldPauseOnHeadphoneDisconnect")
        shouldEnableGaplessPlayback = UserDefaults.standard.bool(forKey: "shouldEnableGaplessPlayback")
        enableDoP = UserDefaults.standard.bool(forKey: "enableDoP")
        super.init()
        player.delegate = self
    
        nowPlayingSubject
            .receive(on: DispatchQueue.main)
            .assign(to: &$nowPlaying)
        
        playbackStateSubject
            .receive(on: DispatchQueue.main)
            .assign(to: &$playbackState)
        
        displayLinkPublisher
            .receive(on: DispatchQueue.main)
            .sink { _ in
                if let time = self.player.time {
                    self.playbackTimeSubject.send(time)
                }
            }
            .store(in: &cancellables)

        configureAudioSession()
        setupRouteChangeHandling()
        configureSpectrumAnalyzer()

    }
    
    private func setupInterruptionHandling() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleInterruption),
            name: AVAudioSession.interruptionNotification,
            object: AVAudioSession.sharedInstance()
        )
    }

    @objc private func handleInterruption(notification: Notification) {
        guard let userInfo = notification.userInfo,
              let interruptionTypeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
              let interruptionType = AVAudioSession.InterruptionType(rawValue: interruptionTypeValue) else {
            return
        }

        switch interruptionType {
        case .began:
            print("音频打断开始，暂停播放")
            player.pause()
        case .ended:
            if let optionsValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt,
               AVAudioSession.InterruptionOptions(rawValue: optionsValue).contains(.shouldResume) {
                print("音频打断结束，恢复播放")
                try? player.play()
            }
        default:
            break
        }
    }