Sprawdź stan odtwarzania AVPlayer

Możesz powiedzieć, że gra używając:

AVPlayer *player = ...
if ((player.rate != 0) && (player.error == nil)) {
    // player is playing
}

Swift 3 extension:

extension AVPlayer {
    var isPlaying: Bool {
        return rate != 0 && error == nil
    }
}

W iOS10 jest teraz wbudowana właściwość: timeControlStatus

Na przykład ta funkcja odtwarza lub wstrzymuje avplayera w zależności od jego statusu i odpowiednio aktualizuje przycisk odtwarzania / pauzy.

@IBAction func btnPlayTap(_ sender: Any) {
    if aPlayer.timeControlStatus == .playing {
        aPlayer.pause()
        btnPlay.setImage(UIImage(named: "control-play"), for: .normal)
    } else if aPlayer.timeControlStatus == .paused {
        aPlayer.play()
        btnPlay.setImage(UIImage(named: "control-pause"), for: .normal)
    }
}

Jeśli chodzi o drugie pytanie, aby wiedzieć, czy avPlayer dotarł do końca, najprostszą rzeczą do zrobienia byłoby skonfigurowanie powiadomienia.

NotificationCenter.default.addObserver(self, selector: #selector(self.didPlayToEnd), name: .AVPlayerItemDidPlayToEndTime, object: nil)

Kiedy dotrze do końca, na przykład, możesz cofnąć go do początku wideo i zresetować Przycisk pauzy do gry.

func didPlayToEnd() {
    aPlayer.seek(to: CMTimeMakeWithSeconds(0, 1))
    btnPlay.setImage(UIImage(named: "control-play"), for: .normal)
}

Te przykłady są przydatne, jeśli tworzysz własne kontrolki, ale jeśli używasz kontrolki AVPlayerViewController, to kontrolki są wbudowane.

Bardziej niezawodną alternatywą dla NSNotification jest dodanie siebie jako obserwatora do właściwości gracza rate.

[self.player addObserver:self
              forKeyPath:@"rate"
                 options:NSKeyValueObservingOptionNew
                 context:NULL];

Następnie sprawdź, czy nowa wartość obserwowanej szybkości wynosi zero, co oznacza, że odtwarzanie zostało zatrzymane z jakiegoś powodu, na przykład dotarcie do końca lub opóźnienie z powodu pustego bufora.

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary<NSString *,id> *)change
                       context:(void *)context {
    if ([keyPath isEqualToString:@"rate"]) {
        float rate = [change[NSKeyValueChangeNewKey] floatValue];
        if (rate == 0.0) {
            // Playback stopped
        } else if (rate == 1.0) {
            // Normal playback
        } else if (rate == -1.0) {
            // Reverse playback
        }
    }
}

W przypadku rate == 0.0, aby dowiedzieć się, co dokładnie spowodowało zatrzymanie odtwarzania, możesz wykonać następujące kontrole:

if (self.player.error != nil) {
    // Playback failed
}
if (CMTimeGetSeconds(self.player.currentTime) >=
    CMTimeGetSeconds(self.player.currentItem.duration)) {
    // Playback reached end
} else if (!self.player.currentItem.playbackLikelyToKeepUp) {
    // Not ready to play, wait until enough data is loaded
}

I nie zapomnij, aby twój gracz zatrzymał się, gdy dotrze do end:

self.player.actionAtItemEnd = AVPlayerActionAtItemEndPause;

Dla :

AVPlayer :

let player = AVPlayer(URL: NSURL(string: "http://www.sample.com/movie.mov"))
if (player.rate != 0 && player.error == nil) {
   println("playing")
}

Aktualizacja:
player.rate > 0 warunek zmieniony na player.rate != 0, ponieważ jeśli film jest odtwarzany w odwrotnej kolejności, to może być ujemny dzięki Julianowi za wskazanie.
Uwaga: to może wyglądać tak samo jak powyżej(Maz) odpowiedź, ale w Swift '!gracz.error 'dawał mi błąd kompilatora, więc musisz sprawdzić błąd za pomocą' player.error = = nil' in Swift.(ponieważ właściwość error nie jest 'Bool' typ)

AVAudioPlayer:

if let theAudioPlayer =  appDelegate.audioPlayer {
   if (theAudioPlayer.playing) {
       // playing
   }
}

AVQueuePlayer:

if let theAudioQueuePlayer =  appDelegate.audioPlayerQueue {
   if (theAudioQueuePlayer.rate != 0 && theAudioQueuePlayer.error == nil) {
       // playing
   }
}

rate czy Nie jest sposobem sprawdzenia, czy film jest odtwarzany (może zostać zablokowany). Z dokumentacji rate:

Wskazuje pożądaną szybkość odtwarzania; 0.0 oznacza "wstrzymane", 1.0 oznacza chęć odtwarzania z naturalną szybkością bieżącego elementu.

Słowa kluczowe "chęć gry" - szybkość 1.0 nie oznacza, że wideo jest odtwarzane.

Rozwiązaniem od iOS 10.0 jest użycie AVPlayerTimeControlStatus, które można zaobserwować na AVPlayer timeControlStatus własność.

Rozwiązanie przed iOS 10.0 (9.0, 8.0 itd.) jest zrolowanie własnego rozwiązania. szybkość 0.0 oznacza, że film jest wstrzymywany. Gdy rate != 0.0 oznacza to, że wideo jest odtwarzane lub jest zablokowane.

Możesz sprawdzić różnicę obserwując czas gracza poprzez: func addPeriodicTimeObserver(forInterval interval: CMTime, queue: DispatchQueue?, using block: @escaping (CMTime) -> Void) -> Any

Blok zwraca bieżący czas gracza w CMTime, więc porównanie lastTime (czasu, który został ostatnio odebrany z bloku) i currentTime (czasu, który blok tylko zgłoszone) powie, czy gracz gra lub jest zablokowany. Na przykład, jeśli lastTime == currentTime i rate != 0.0, to gracz stoi w miejscu.

Jak zauważyli inni, sprawdzenie, czy odtwarzanie zostało zakończone, wskazuje AVPlayerItemDidPlayToEndTimeNotification.

Rozszerzenie Swift na podstawie odpowiedzi maz

extension AVPlayer {

    var isPlaying: Bool {
        return ((rate != 0) && (error == nil))
    }
}

Szybka wersja odpowiedzi maxkonovalova jest taka:

player.addObserver(self, forKeyPath: "rate", options: NSKeyValueObservingOptions.New, context: nil)

I

override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) {
    if keyPath == "rate" {
        if let rate = change?[NSKeyValueChangeNewKey] as? Float {
            if rate == 0.0 {
                print("playback stopped")
            }
            if rate == 1.0 {
                print("normal playback")
            }
            if rate == -1.0 {
                print("reverse playback")
            }
        }
    }
}

Dziękuję maxkonovalov!