Miałem wiele problemów próbując dowiedzieć się status AVPlayer. Właściwość status nie zawsze wydawała się bardzo pomocna, a to doprowadziło do niekończącej się frustracji, gdy próbowałem poradzić sobie z przerwami w sesji audio. Czasami AVPlayer powiedział mi, że jest gotowy do gry (z AVPlayerStatusReadyToPlay), Kiedy tak naprawdę nie wydaje się być. Użyłem metody KVO, ale nie we wszystkich przypadkach.

Aby uzupełnić, gdy właściwość status nie była użyteczna, zapytałem o ilość strumienia że AVPlayer załadował patrząc na właściwość loadedTimeRanges AVPlayer's currentItem (która jest AVPlayerItem).

To wszystko jest trochę mylące, ale tak to wygląda:

NSValue *val = [[[audioPlayer currentItem] loadedTimeRanges] objectAtIndex:0];
CMTimeRange timeRange;
[val getValue:&timeRange];
CMTime duration = timeRange.duration;
float timeLoaded = (float) duration.value / (float) duration.timescale; 

if (0 == timeLoaded) {
    // AVPlayer not actually ready to play
} else {
    // AVPlayer is ready to play
}

Po zbadaniu wielu i wypróbowaniu wielu sposobów zauważyłem, że normalnie status obserwator nie jest tym lepiej wiedzieć kiedy AVPlayer obiekt jest gotowy do gry, ponieważ obiekt może być gotowy do gry, ale nie oznacza to, że będzie natychmiast odtwarzany.

Lepiej wiedzieć, że to jest z loadedTimeRanges.

Dla obserwatora rejestru

[playerClip addObserver:self forKeyPath:@"currentItem.loadedTimeRanges" options:NSKeyValueObservingOptionNew context:nil];

Listen the observer

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if (object == playerClip && [keyPath isEqualToString:@"currentItem.loadedTimeRanges"]) {
        NSArray *timeRanges = (NSArray*)[change objectForKey:NSKeyValueChangeNewKey];
        if (timeRanges && [timeRanges count]) {
            CMTimeRange timerange=[[timeRanges objectAtIndex:0]CMTimeRangeValue];
            float currentBufferDuration = CMTimeGetSeconds(CMTimeAdd(timerange.start, timerange.duration));
            CMTime duration = playerClip.currentItem.asset.duration;
            float seconds = CMTimeGetSeconds(duration);

            //I think that 2 seconds is enough to know if you're ready or not
            if (currentBufferDuration > 2 || currentBufferDuration == seconds) {
                // Ready to play. Your logic here
            }
        } else {
            [[[UIAlertView alloc] initWithTitle:@"Alert!" message:@"Error trying to play the clip. Please try again" delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil, nil] show];
        }
    }
}

For remove observer (dealloc, viewWillDissapear lub przed rejestr observer) its a good places for called

- (void)removeObserverForTimesRanges
{
    @try {
        [playerClip removeObserver:self forKeyPath:@"currentItem.loadedTimeRanges"];
    } @catch(id anException){
        NSLog(@"excepcion remove observer == %@. Remove previously or never added observer.",anException);
        //do nothing, obviously it wasn't attached because an exception was thrown
    }
}

Swift Solution

var observer: NSKeyValueObservation?

func prepareToPlay() {
    let url = <#Asset URL#>
    // Create asset to be played
    asset = AVAsset(url: url)

    let assetKeys = [
        "playable",
        "hasProtectedContent"
    ]
    // Create a new AVPlayerItem with the asset and an
    // array of asset keys to be automatically loaded
    playerItem = AVPlayerItem(asset: asset,
                              automaticallyLoadedAssetKeys: assetKeys)

    // Register as an observer of the player item's status property
    self.observer = playerItem.observe(\.status, options:  [.new, .old], changeHandler: { (playerItem, change) in
        if playerItem.status == .readyToPlay {
            //Do your work here
        }
    })

    // Associate the player item with the player
    player = AVPlayer(playerItem: playerItem)
}

Możesz również unieważnić obserwatora w ten sposób

self.observer.invalidate()

Ważne: należy zachować zmienną observer, w przeciwnym razie zostanie ona wyłączona i zmienna changeHandler nie będzie już wywoływana. Więc nie Definiuj obserwatora jako zmiennej funkcji, ale zdefiniuj ją jako zmienną instancji, jak w podanym przykładzie.

Ta składnia obserwatora wartości klucza jest nowa w Swift 4.

Aby uzyskać więcej informacji, zobacz tutaj https://github.com/ole/whats-new-in-swift-4/blob/master/Whats-new-in-Swift-4.playground/Pages/Key%20paths.xcplaygroundpage/Contents.swift

private var playbackLikelyToKeepUpContext = 0

Dla obserwatora rejestru

avPlayer.addObserver(self, forKeyPath: "currentItem.playbackLikelyToKeepUp",
        options: .new, context: &playbackLikelyToKeepUpContext)

Listen the observer

 override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if context == &playbackLikelyToKeepUpContext {
        if avPlayer.currentItem!.isPlaybackLikelyToKeepUp {
           // loadingIndicatorView.stopAnimating() or something else
        } else {
           // loadingIndicatorView.startAnimating() or something else
        }
    }
}

Do usunięcia obserwatora

deinit {
    avPlayer.removeObserver(self, forKeyPath: "currentItem.playbackLikelyToKeepUp")
}

Kluczowym punktem w kodzie jest właściwość instancji isplaybacklikelytokeepup.

Miałem problemy z nie otrzymywaniem żadnych połączeń zwrotnych.

Okazuje się, że to zależy od tego, jak stworzysz strumień. W moim przypadku użyłem playerItem do inicjalizacji, a więc musiałem dodać obserwatora do elementu zamiast.

Na przykład:

- (void) setup
{
    ...
    self.playerItem = [AVPlayerItem playerItemWithAsset:asset];
    self.player = [AVPlayer playerWithPlayerItem:self.playerItem];
    ... 

     // add callback
     [self.player.currentItem addObserver:self forKeyPath:@"status" options:0 context:nil];
}

// the callback method
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
                    change:(NSDictionary *)change context:(void *)context
{
    NSLog(@"[VideoView] player status: %i", self.player.status);

    if (object == self.player.currentItem && [keyPath isEqualToString:@"status"])
    {
        if (self.player.currentItem.status == AVPlayerStatusReadyToPlay)
        {
           //do stuff
        }
    }
}

// cleanup or it will crash
-(void)dealloc
{
    [self.player.currentItem removeObserver:self forKeyPath:@"status"];
}

W oparciu o odpowiedź Tima Cambera , Oto funkcja Swift, której używam:

private func isPlayerReady(_ player:AVPlayer?) -> Bool {

    guard let player = player else { return false }

    let ready = player.status == .readyToPlay

    let timeRange = player.currentItem?.loadedTimeRanges.first as? CMTimeRange
    guard let duration = timeRange?.duration else { return false } // Fail when loadedTimeRanges is empty
    let timeLoaded = Int(duration.value) / Int(duration.timescale) // value/timescale = seconds
    let loaded = timeLoaded > 0

    return ready && loaded
}

Lub jako rozszerzenie

extension AVPlayer {
    var ready:Bool {
        let timeRange = currentItem?.loadedTimeRanges.first as? CMTimeRange
        guard let duration = timeRange?.duration else { return false }
        let timeLoaded = Int(duration.value) / Int(duration.timescale) // value/timescale = seconds
        let loaded = timeLoaded > 0

        return status == .readyToPlay && loaded
    }
}

Sprawdź status aktualnego gracza:

if (player.currentItem.status == AVPlayerItemStatusReadyToPlay)

Myślę, że lepiej będzie, jeśli gracz użyje initWithUrl. Nie sądzę, że to rozwiąże twój problem, ale jest lepiej.