How to detect AVPlayer actually started to play in swift

Question

Hello I have set my UISliderminimum value to 0.00. Then I set it's max value in this way.

self.viewPlayer.layer.addSublayer(playerLayer)
    let duration : CMTime = avPlayer.avPlayer.currentItem!.asset.duration
    let seconds : Float64 = CMTimeGetSeconds(duration)

    sliderBar.maximumValue=Float(seconds)
    sliderBar!.isContinuous = false
    sliderBar!.tintColor = UIColor.green

But I am getting this exception

*** Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason: 'Attempting to set a slider's minimumValue (0.000000) to be larger than the maximumValue (nan)'
enter code here

I know after prepareForPlay() to actual playing it takes some time to really play the video. So how can I detect when the player really started to play the video? Please help me. Thanks

Hope this helps: http://stackoverflow.com/questions/5401437/knowing-when-avplayer-object-is-ready-to-play — nynohu, Nov 24 '16 at 08:58
Player.play() is method that play your file so you can track it — Himanshu Moradiya, Nov 24 '16 at 09:30
@HimanshuMoradiya yeas. I want to detect when player starts to play actually. Because it takes some time to play after load the video — user1960169, Nov 24 '16 at 12:45
This answer of @Jose might help you, http://stackoverflow.com/questions/5401437/knowing-when-avplayer-object-is-ready-to-play — Arpit B Parekh, May 10 '17 at 09:49

score 41 · Answer 1 · answered May 29 '18 at 11:41

Since iOS 10 you can observe timeControlStatus property of AVPlayer. It can be .playing.

Check the code:

private func setupAVPlayer() {
    avPlayer.addObserver(self, forKeyPath: "status", options: [.old, .new], context: nil)
    if #available(iOS 10.0, *) {
        avPlayer.addObserver(self, forKeyPath: "timeControlStatus", options: [.old, .new], context: nil)
    } else {
        avPlayer.addObserver(self, forKeyPath: "rate", options: [.old, .new], context: nil)
    }
}

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if object as AnyObject? === avPlayer {
        if keyPath == "status" {
            if avPlayer.status == .readyToPlay {
                avPlayer.play()
            }
        } else if keyPath == "timeControlStatus" {
            if #available(iOS 10.0, *) {
                if avPlayer.timeControlStatus == .playing {
                    videoCell?.muteButton.isHidden = false
                } else {
                    videoCell?.muteButton.isHidden = true
                }
            }
        } else if keyPath == "rate" {
            if avPlayer.rate > 0 {
                videoCell?.muteButton.isHidden = false
            } else {
                videoCell?.muteButton.isHidden = true
            }
        }
    }
}

score 19 · Answer 2 · answered Sep 08 '17 at 16:38

19

Here is what I did to actually know when video started (not when it's only ready to start).

Swift 4

player = AVPlayer(url: URL(fileURLWithPath: path))
player.addObserver(self, forKeyPath: "rate", options: NSKeyValueObservingOptions.new, context: nil)

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if keyPath == "rate" {
        if player.rate > 0 {
            print("video started")
        }
    }
}

answered Sep 08 '17 at 16:38

Skoua

3,373
3
38
51

@AmritTiwari Well it is Swift 4. – Skoua Mar 19 '18 at 01:01
Have you checked if observeValue() is doing something? – Skoua Mar 20 '18 at 14:47
yeah i have done by using timeobserver method and thanks for the reply. – Amrit Tiwari Mar 20 '18 at 16:28
1

This works like a charm, when the player starts and stop, thanks a lot – Hugo Fortis Jun 10 '18 at 04:43

score 12 · Answer 3 · edited Aug 04 '17 at 14:40

12

You can add an observer on the object of your AVPlayer like this

player.addObserver(self, forKeyPath: "status", options: NSKeyValueObservingOptions.new, context: nil)

and you can check the status change with your AVPlayer like this

 func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutableRawPointer) {
    if keyPath == "status" {
        print(player.status)
    }
}

edited Aug 04 '17 at 14:40

shim

9,289
12
69
108

answered Nov 24 '16 at 09:07

Rajat

10,977
3
38
55

player.status == AVPlayerStatusReadyToPlay does this mean the video is started to play? – user1960169 Nov 24 '16 at 09:24
this means avplayer will begin to play now. – Rajat Nov 24 '16 at 09:26
This just print as AVPlayerStatus – user1960169 Nov 24 '16 at 12:46
1

Have you tried getting duration here when the status is readyToPlay ? – Rajat Nov 25 '16 at 05:12
1

@Rajat This does not tell if video is started playing. It only says video is ready to be played. `readyToPlay`. – Mohammad Zaid Pathan Sep 26 '18 at 07:52
1

This doesn't answer the question. "rate" or "timeControlStatus" are correct answers. – thefaj May 30 '21 at 18:03

score 3 · Answer 4 · answered Dec 08 '17 at 23:50

From Apple's docs: You can observe an AVPlayerLayer object’s readyForDisplay property to be notified when the layer has user-visible content. In particular, you might insert the player layer into the layer tree only when there is something for the user to look at and then perform a transition from

Joony · Answer 5 · 2022-12-01T09:18:35.373

3

You could create a Combine publisher and observe the rate property:

let isPlayingPublisher: AnyPublisher<Bool, Never> = NotificationCenter.default
        .publisher(for: AVPlayer.rateDidChangeNotification, object: player)
        .compactMap({ $0.object as? AVPlayer })
        .map(\.rate)
        .map({ $0 != 0 })
        .eraseToAnyPublisher()

In SwiftUI you could then receive the value:

.onReceive(isPlayingPublisher) { isPlaying in
    
}

edited Dec 01 '22 at 09:18

answered Nov 30 '22 at 13:56

Joony

4,498
2
30
39

`AVPlayer.rateDidChangeNotification` is available in iOS 15+. "Thank you very much" – Gargo Jun 29 '23 at 08:02

score -2 · Answer 6 · answered May 31 '18 at 11:38

Declare AVPlayer Global

var streamPlayer = AVPlayer()

func playStreamAudio( for audioUrl:String)
    {
        guard streamPlayer.timeControlStatus != .playing else {
            streamPlayer.pause()
            return
        }
        let url = audioUrl //"http://192.168.71.11:7891/rec.wav"
        let playerItem = AVPlayerItem(url: URL(string:url)!)
        streamPlayer = AVPlayer(playerItem:playerItem)
        streamPlayer.rate = 1.0;
        streamPlayer.volume = 1.0
        streamPlayer.play()
    }

score -3 · Answer 7 · answered Aug 25 '20 at 00:46

SUPER EASY SOLUTION SWIFT 4-5:

Just check the timeControlStatus!: (also works with PlayerQueue)

    if avPlayer?.timeControlStatus.rawValue == 2 {
       
    //video is playing (playing)

    } else if avPlayer?.timeControlStatus.rawValue == 0 { 
    
    //video is not playing (paused)
    
    }

the raw value will give you its current state :)

score -6 · Answer 8 · answered Feb 23 '19 at 23:46

-6

Another, simpler, approach is something like:

if videoPlayer.rate != 0 && videoPlayer.error == nil {
            print("video player is playing.................")
        } else {
            print("video player is NOT playing.")
        }

Where videoPlayer is of type AVPlayer, obviously.

answered Feb 23 '19 at 23:46

AdjunctProfessorFalcon

1,790
6
26
62

1

but its not reactive – Mike Glukhov Jun 11 '19 at 10:03

How to detect AVPlayer actually started to play in swift

8 Answers8

Linked