如何在ios swift中从URL播放mp3音频

我得到mp3 url作为api调用的响应。 我想播放那个音频，那我怎么做呢？（ios swift）

这是我的回答

 {
    content = "En este primer programa se tratar\U00e1n asuntos tan importante como este y aquel sin descuidar un poco de todo lo dem\U00e1s";
    file = "http://radio.spainmedia.es/wp-content/uploads/2015/12/ogilvy.mp3";
    image = "http://radio.spainmedia.es/wp-content/uploads/2015/12/tapas.jpg";
    number = 0001;
    subtitle = Titulareando;
    title = "Tapa 1";
}

这是我的密码：

 @IBAction func btnplayaudio(sender: AnyObject) {
    let urlstring = "http://radio.spainmedia.es/wp-content/uploads/2015/12/tailtoddle_lo4.mp3"
    let url = NSURL(string: urlstring)
    print("the url = \(url!)")

    play(url!)

}

func play(url:NSURL) {
    print("playing \(url)")

    do {
        self.player = try AVAudioPlayer(contentsOfURL: url)
        player.prepareToPlay()
        player.volume = 1.0
        player.play()
    } catch let error as NSError {
        self.player = nil
        print(error.localizedDescription)
    } catch {
        print("AVAudioPlayer init failed")
    }

}

---

我哪里出错了？

在swift2中播放声音是错误的

func playSound(soundUrl: String)
{
   let sound = NSURL(soundUrl)
  do{
      let audioPlayer = try AVAudioPlayer(contentsOfURL: sound)
      audioPlayer.prepareToPlay()
      audioPlayer.play()
  }catch {
      print("Error..")
  }
}

让我知道它是否有效。

我尝试了以下方法

let urlstring = "http://radio.spainmedia.es/wp-content/uploads/2015/12/tailtoddle_lo4.mp3"
let url = NSURL(string: urlstring)
print("the url = \(url!)")
downloadFileFromURL(url!)

添加以下方法

func downloadFileFromURL(url:NSURL){

    var downloadTask:NSURLSessionDownloadTask
    downloadTask = NSURLSession.sharedSession().downloadTaskWithURL(url, completionHandler: { [weak self](URL, response, error) -> Void in
        self?.play(URL)
    })
        
    downloadTask.resume()
    
}

还有你现在的打法

func play(url:NSURL) {
    print("playing \(url)")
    
    do {
        self.player = try AVAudioPlayer(contentsOfURL: url)
        player.prepareToPlay()
        player.volume = 1.0
        player.play()
    } catch let error as NSError {
        //self.player = nil
        print(error.localizedDescription)
    } catch {
        print("AVAudioPlayer init failed")
    }
    
}

下载mp3文件，然后尝试播放，但AVAudioPlayer无法为您下载mp3文件。我可以下载音频文件并播放它

请记住将其添加到info.plist中，因为您是从http源加载的，并且需要为iOS 9+设置以下内容

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <true/>
</dict>
</plist>

NSAllowsArbitraryLoads

使用代替AVAudioPlayer来播放远程内容。根据文档，AVAudioPlayer需要mp3文件来播放音频。AVAudioPlayer不支持

试试这个代码，对我来说很好

func play(url:NSURL) {
    print("playing \(url)")

    do {

        let playerItem = AVPlayerItem(URL: url)

        self.player = try AVPlayer(playerItem:playerItem)
        player!.volume = 1.0
        player!.play()
    } catch let error as NSError {
        self.player = nil
        print(error.localizedDescription)
    } catch {
        print("AVAudioPlayer init failed")
    }
}

请记住在info.plist文件中设置应用程序传输安全性（ATS）

<key>NSAppTransportSecurity</key>
    <dict>
        <key>NSAllowsArbitraryLoads</key>
        <true/>
    </dict>

NSAppTransportSecurity
NSAllowsArbitraryLoads

由于

AVPlayer

非常有限（例如，如果不重新生成整个

AVPlayer

您就不能在那里更改

url

，我认为您应该使用

AVQueuePlayer

：

从：

AVQueuePlayer是AVPlayer的一个子类，用于播放许多项目 使用此类，您可以创建和管理 由本地或逐步下载的文件组成的播放器项目 媒体，如QuickTime电影或MP3音频文件，以及媒体 使用HTTP实时流服务

因此，在Swift 3中，其工作原理如下：

lazy var playerQueue : AVQueuePlayer = {
    return AVQueuePlayer()
}()

---

Swift 4

func playSound(soundUrl: String) {
    let sound = URL(fileURLWithPath: soundUrl)
    do {
        let audioPlayer = try AVAudioPlayer(contentsOf: sound)
        audioPlayer.prepareToPlay()
        audioPlayer.play()
    }catch let error {
        print("Error: \(error.localizedDescription)")
    }
}

---

经过一些研究，有些失望，因为没有一个答案解决了我的问题，我找到了一个解决方案，这是最终的结果。被接受的答案是对的一半，你仍然需要创建一个

AVPlayerLayer

let url = URL(string: "https://www.myinstants.com/media/sounds/cade-o-respeito.mp3" ?? "")
playerItem = AVPlayerItem(url: url!)
player = AVPlayer(playerItem: playerItem)

let playerLayer = AVPlayerLayer(player: player)
playerLayer.frame = CGRect(x: 0, y: 0, width: 10, height: 10)
self.contentView.layoutSublayers(of: playerLayer)

player?.play()

斯威夫特4

1-

导入AVFoundation

2-声明玩家

var player : AVPlayer?

3-在ViewDidLoad中调用函数并像字符串一样传递流url

loadRadio(radioURL: (radioStation?.streamURL)!)

4-要玩的功能

func loadRadio(radioURL: String) {

        guard let url = URL.init(string: radioURL) else { return }
        let playerItem = AVPlayerItem.init(url: url)
        player = AVPlayer.init(playerItem: playerItem)
        player?.play()
        startNowPlayingAnimation(true)
        played = true
    }

---

对我来说，这是在swift中播放音频流的最好、最简单的方法。

创建一个完整的音频播放器，其中包含进度条和其他内容。。。

var player : AVPlayer?
func playSound()
    {
      guard  let url = URL(string: "https://file-examples.com/wp-content/uploads/2017/11/file_example_MP3_700KB.mp3")
     else 
        {
          print("error to get the mp3 file")
          return
        }
     do{
         try AVAudioSession.sharedInstance().setCategory(.playback, mode.default)
         try AVAudioSession.sharedInstance().setActive(true)
         player = try AVPlayer(url: url as URL)
         guard let player = player
               else 
                   { 
                     return 
                   }
         player.play()
      } catch let error {
            print(error.localizedDescription)
               }
   }

swift 5

和

Xcode 12.1

var player: AVPlayer?
var playerItem:AVPlayerItem?
fileprivate let seekDuration: Float64 = 10


@IBOutlet weak var labelOverallDuration: UILabel!
@IBOutlet weak var labelCurrentTime: UILabel!
@IBOutlet weak var playbackSlider: UISlider!
@IBOutlet weak var ButtonPlay: UIButton!

//call this mehtod to init audio player 
func initAudioPlayer{
    let url = URL(string: "https://argaamplus.s3.amazonaws.com/eb2fa654-bcf9-41de-829c-4d47c5648352.mp3")
    let playerItem:AVPlayerItem = AVPlayerItem(url: url!)
    player = AVPlayer(playerItem: playerItem)
    
    playbackSlider.minimumValue = 0
    
    //To get overAll duration of the audio
    let duration : CMTime = playerItem.asset.duration
    let seconds : Float64 = CMTimeGetSeconds(duration)
    labelOverallDuration.text = self.stringFromTimeInterval(interval: seconds)
    
    //To get the current duration of the audio
    let currentDuration : CMTime = playerItem.currentTime()
    let currentSeconds : Float64 = CMTimeGetSeconds(currentDuration)
    labelCurrentTime.text = self.stringFromTimeInterval(interval: currentSeconds)
    
    playbackSlider.maximumValue = Float(seconds)
    playbackSlider.isContinuous = true
    
    
    
    player!.addPeriodicTimeObserver(forInterval: CMTimeMakeWithSeconds(1, preferredTimescale: 1), queue: DispatchQueue.main) { (CMTime) -> Void in
        if self.player!.currentItem?.status == .readyToPlay {
            let time : Float64 = CMTimeGetSeconds(self.player!.currentTime());
            self.playbackSlider.value = Float ( time );
            self.labelCurrentTime.text = self.stringFromTimeInterval(interval: time)
        }
        let playbackLikelyToKeepUp = self.player?.currentItem?.isPlaybackLikelyToKeepUp
        if playbackLikelyToKeepUp == false{
            print("IsBuffering")
            self.ButtonPlay.isHidden = true
            //        self.loadingView.isHidden = false
        } else {
            //stop the activity indicator
            print("Buffering completed")
            self.ButtonPlay.isHidden = false
            //        self.loadingView.isHidden = true
        }
    }
   
   //change the progress value
    playbackSlider.addTarget(self, action: #selector(playbackSliderValueChanged(_:)), for: .valueChanged)
    
    //check player has completed playing audio
    NotificationCenter.default.addObserver(self, selector: #selector(self.finishedPlaying(_:)), name: NSNotification.Name.AVPlayerItemDidPlayToEndTime, object: playerItem)}


@objc func playbackSliderValueChanged(_ playbackSlider:UISlider) {
    let seconds : Int64 = Int64(playbackSlider.value)
    let targetTime:CMTime = CMTimeMake(value: seconds, timescale: 1)
    player!.seek(to: targetTime)
    if player!.rate == 0 {
        player?.play()
    }
}

@objc func finishedPlaying( _ myNotification:NSNotification) {
    ButtonPlay.setImage(UIImage(named: "play"), for: UIControl.State.normal)
    //reset player when finish   
    playbackSlider.value = 0
    let targetTime:CMTime = CMTimeMake(value: 0, timescale: 1)
    player!.seek(to: targetTime)
}

@IBAction func playButton(_ sender: Any) {
    print("play Button")
    if player?.rate == 0
    {
        player!.play()
        self.ButtonPlay.isHidden = true
        //        self.loadingView.isHidden = false
        ButtonPlay.setImage(UIImage(systemName: "pause"), for: UIControl.State.normal)
    } else {
        player!.pause()
        ButtonPlay.setImage(UIImage(systemName: "play"), for: UIControl.State.normal)
    }
    
}


func stringFromTimeInterval(interval: TimeInterval) -> String {
    let interval = Int(interval)
    let seconds = interval % 60
    let minutes = (interval / 60) % 60
    let hours = (interval / 3600)
    return String(format: "%02d:%02d:%02d", hours, minutes, seconds)
}



@IBAction func seekBackWards(_ sender: Any) {
    if player == nil { return }
    let playerCurrenTime = CMTimeGetSeconds(player!.currentTime())
    var newTime = playerCurrenTime - seekDuration
    if newTime < 0 { newTime = 0 }
    player?.pause()
    let selectedTime: CMTime = CMTimeMake(value: Int64(newTime * 1000 as Float64), timescale: 1000)
    player?.seek(to: selectedTime)
    player?.play()

}


@IBAction func seekForward(_ sender: Any) {
    if player == nil { return }
    if let duration = player!.currentItem?.duration {
       let playerCurrentTime = CMTimeGetSeconds(player!.currentTime())
       let newTime = playerCurrentTime + seekDuration
       if newTime < CMTimeGetSeconds(duration)
       {
          let selectedTime: CMTime = CMTimeMake(value: Int64(newTime * 1000 as 
       Float64), timescale: 1000)
          player!.seek(to: selectedTime)
       }
       player?.pause()
       player?.play()
      }
}

var播放器：AVPlayer？
var playerItem:AVPlayerItem？
fileprivate let seekDuration:Float64=10
@IBOUTLE弱var标签平均持续时间：UILabel！
@IBOutlet弱var标签CurrentTime:UILabel！
@ibvar playbackSlider:UISlider！
@IBVAR按钮显示：UIButton！
//调用此方法初始化音频播放器
音频播放器{
让url=url（字符串：https://argaamplus.s3.amazonaws.com/eb2fa654-bcf9-41de-829c-4d47c5648352.mp3")
让playerItem:AVPlayerItem=AVPlayerItem（url:url！）
player=AVPlayer（playerItem:playerItem）
playbackSlider.minimumValue=0
//获取音频的总持续时间
let duration:CMTime=playerItem.asset.duration
let seconds:Float64=CMTimeGetSeconds（持续时间）
labelOverallDuration.text=self.stringFromTimeInterval（间隔：秒）
//获取音频的当前持续时间
让currentDuration:CMTime=playerItem.currentTime（）
让currentSeconds:Float64=CMTimeGetSeconds（currentDuration）
labelCurrentTime.text=self.stringFromTimeInterval（间隔：currentSeconds）
playbackSlider.maximumValue=浮动（秒）
playbackSlider.isContinuous=true
player！.addPeriodicTimeObserver（forInterval:CMTimeMakeWithSeconds（1，preferredTimescale:1），queue:DispatchQueue.main）{（CMTime）->Void in
如果self.player！.currentItem？.status=.readyToPlay{
让时间：Float64=CMTimeGetSeconds（self.player！.currentTime（））；
self.playbackSlider.value=浮动（时间）；
self.labelCurrentTime.text=self.stringFromTimeInterval（间隔：时间）
}
让playbackLikelyToKeepUp=self.player？.currentItem？.isPlaybackLikelyToKeepUp
如果playbackLikelyToKeepUp==false{
打印（“IsBuffering”）
self.ButtonPlay.ishiden=true
//self.loadingView.ishiden=false
}否则{
//停止活动指示器
打印（“缓冲完成”）
self.ButtonPlay.ishiden=false
//self.loadingView.ishiden=true
}
}
//更改进度值
playbackSlider.addTarget（自身，操作：#选择器（playbackSliderValueChanged（：）），for:.valueChanged）
//检查播放器是否已完成音频播放
NotificationCenter.default.addObserver（self，选择器：#选择器（self.finishedPlaying（：）），名称：NSNotification.name.AVPlayerItemDidPlayToEndTime，对象：playerItem）}
@objc func playbackSliderValueChanged（uPlaybackSlider:UISlider）{
让秒数：Int64=Int64（playbackSlider.value）
让targetTime:CMTime=CMTimeMake（值：秒，时间刻度：1）
player！.seek（收件人：targetTime）
如果玩家%.rate==0{
玩家？.play（）
}
}
@objc func完成布局（uuMyNotification:NSNotification）{
ButtonPlay.setImage（UIImage（名为：“播放”），用于：UIControl.State.normal）
//完成后重置播放器
playbackSlider.value=0
让targetTime:CMTime=CMTimeMake（值：0，时间刻度：1）
player！.seek（收件人：targetTime）
}
@iAction func播放按钮（\发送方：任意）{
打印（“播放按钮”）
如果玩家？.rate==0
{
player！.play（）
self.ButtonPlay.ishiden=true
//self.loadingView.ishiden=false
ButtonPlay.setImage（UIImage（系统名称：“暂停”），用于：UIControl.State.normal）
}否则{
player！.pause（）
ButtonPlay.setImage（UIImage（系统名称：“播放”），用于：UIControl.State.normal）
}
}
func stringFromTimeInterval(
var player: AVPlayer?
var playerItem:AVPlayerItem?
fileprivate let seekDuration: Float64 = 10


@IBOutlet weak var labelOverallDuration: UILabel!
@IBOutlet weak var labelCurrentTime: UILabel!
@IBOutlet weak var playbackSlider: UISlider!
@IBOutlet weak var ButtonPlay: UIButton!

//call this mehtod to init audio player 
func initAudioPlayer{
    let url = URL(string: "https://argaamplus.s3.amazonaws.com/eb2fa654-bcf9-41de-829c-4d47c5648352.mp3")
    let playerItem:AVPlayerItem = AVPlayerItem(url: url!)
    player = AVPlayer(playerItem: playerItem)
    
    playbackSlider.minimumValue = 0
    
    //To get overAll duration of the audio
    let duration : CMTime = playerItem.asset.duration
    let seconds : Float64 = CMTimeGetSeconds(duration)
    labelOverallDuration.text = self.stringFromTimeInterval(interval: seconds)
    
    //To get the current duration of the audio
    let currentDuration : CMTime = playerItem.currentTime()
    let currentSeconds : Float64 = CMTimeGetSeconds(currentDuration)
    labelCurrentTime.text = self.stringFromTimeInterval(interval: currentSeconds)
    
    playbackSlider.maximumValue = Float(seconds)
    playbackSlider.isContinuous = true
    
    
    
    player!.addPeriodicTimeObserver(forInterval: CMTimeMakeWithSeconds(1, preferredTimescale: 1), queue: DispatchQueue.main) { (CMTime) -> Void in
        if self.player!.currentItem?.status == .readyToPlay {
            let time : Float64 = CMTimeGetSeconds(self.player!.currentTime());
            self.playbackSlider.value = Float ( time );
            self.labelCurrentTime.text = self.stringFromTimeInterval(interval: time)
        }
        let playbackLikelyToKeepUp = self.player?.currentItem?.isPlaybackLikelyToKeepUp
        if playbackLikelyToKeepUp == false{
            print("IsBuffering")
            self.ButtonPlay.isHidden = true
            //        self.loadingView.isHidden = false
        } else {
            //stop the activity indicator
            print("Buffering completed")
            self.ButtonPlay.isHidden = false
            //        self.loadingView.isHidden = true
        }
    }
   
   //change the progress value
    playbackSlider.addTarget(self, action: #selector(playbackSliderValueChanged(_:)), for: .valueChanged)
    
    //check player has completed playing audio
    NotificationCenter.default.addObserver(self, selector: #selector(self.finishedPlaying(_:)), name: NSNotification.Name.AVPlayerItemDidPlayToEndTime, object: playerItem)}


@objc func playbackSliderValueChanged(_ playbackSlider:UISlider) {
    let seconds : Int64 = Int64(playbackSlider.value)
    let targetTime:CMTime = CMTimeMake(value: seconds, timescale: 1)
    player!.seek(to: targetTime)
    if player!.rate == 0 {
        player?.play()
    }
}

@objc func finishedPlaying( _ myNotification:NSNotification) {
    ButtonPlay.setImage(UIImage(named: "play"), for: UIControl.State.normal)
    //reset player when finish   
    playbackSlider.value = 0
    let targetTime:CMTime = CMTimeMake(value: 0, timescale: 1)
    player!.seek(to: targetTime)
}

@IBAction func playButton(_ sender: Any) {
    print("play Button")
    if player?.rate == 0
    {
        player!.play()
        self.ButtonPlay.isHidden = true
        //        self.loadingView.isHidden = false
        ButtonPlay.setImage(UIImage(systemName: "pause"), for: UIControl.State.normal)
    } else {
        player!.pause()
        ButtonPlay.setImage(UIImage(systemName: "play"), for: UIControl.State.normal)
    }
    
}


func stringFromTimeInterval(interval: TimeInterval) -> String {
    let interval = Int(interval)
    let seconds = interval % 60
    let minutes = (interval / 60) % 60
    let hours = (interval / 3600)
    return String(format: "%02d:%02d:%02d", hours, minutes, seconds)
}



@IBAction func seekBackWards(_ sender: Any) {
    if player == nil { return }
    let playerCurrenTime = CMTimeGetSeconds(player!.currentTime())
    var newTime = playerCurrenTime - seekDuration
    if newTime < 0 { newTime = 0 }
    player?.pause()
    let selectedTime: CMTime = CMTimeMake(value: Int64(newTime * 1000 as Float64), timescale: 1000)
    player?.seek(to: selectedTime)
    player?.play()

}


@IBAction func seekForward(_ sender: Any) {
    if player == nil { return }
    if let duration = player!.currentItem?.duration {
       let playerCurrentTime = CMTimeGetSeconds(player!.currentTime())
       let newTime = playerCurrentTime + seekDuration
       if newTime < CMTimeGetSeconds(duration)
       {
          let selectedTime: CMTime = CMTimeMake(value: Int64(newTime * 1000 as 
       Float64), timescale: 1000)
          player!.seek(to: selectedTime)
       }
       player?.pause()
       player?.play()
      }
}