Wie kann ich überprüfen, ob meine AVPlayer ist die Pufferung?

Will ich erkennen, ob mein AVPlayer ist die Pufferung für den aktuellen Standort, so dass ich zeigen kann, einen loader oder so etwas. Aber ich kann nicht scheinen, etwas zu finden, in der Dokumentation für AVPlayer.

InformationsquelleAutor der Frage vrwim | 2016-08-10

Können Sie beobachten Sie die Werte Ihrer player.currentItem:

playerItem.addObserver(self, forKeyPath: "playbackBufferEmpty", options: .New, context: nil)
playerItem.addObserver(self, forKeyPath: "playbackLikelyToKeepUp", options: .New, context: nil)
playerItem.addObserver(self, forKeyPath: "playbackBufferFull", options: .New, context: nil)

dann

override public func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) {
    if object is AVPlayerItem {
        switch keyPath {
            case "playbackBufferEmpty":
               //Show loader

            case "playbackLikelyToKeepUp":
                //Hide loader

            case "playbackBufferFull":
                //Hide loader
        }
    }
}

InformationsquelleAutor der Antwort Marco Santarossa

Akzeptierte Antwort hat bei mir nicht funktioniert, ich verwendete den folgenden code, um zu zeigen, das loader-effizient.

Swift 3

//properties 
var observer:Any!
var player:AVPlayer!


self.observer = self.player.addPeriodicTimeObserver(forInterval: CMTimeMake(1, 600), queue: DispatchQueue.main) {
    [weak self] time in

    if self?.player.currentItem?.status == AVPlayerItemStatus.readyToPlay {

        if let isPlaybackLikelyToKeepUp = self?.player.currentItem?.isPlaybackLikelyToKeepUp {
            //do what ever you want with isPlaybackLikelyToKeepUp value, for example, show or hide a activity indicator.
        }
    }
}

InformationsquelleAutor der Antwort aytek

Swift 4 Bemerkungen:

var playerItem: AVPlayerItem?
var playbackLikelyToKeepUpKeyPathObserver: NSKeyValueObservation?
var playbackBufferEmptyObserver: NSKeyValueObservation?
var playbackBufferFullObserver: NSKeyValueObservation?

private func observeBuffering() {
    let playbackBufferEmptyKeyPath = \AVPlayerItem.playbackBufferEmpty
    playbackBufferEmptyObserver = playerItem?.observe(playbackBufferEmptyKeyPath, options: [.new]) { [weak self] (_, _) in
        //show buffering
    }

    let playbackLikelyToKeepUpKeyPath = \AVPlayerItem.playbackLikelyToKeepUp
    playbackLikelyToKeepUpKeyPathObserver = playerItem?.observe(playbackLikelyToKeepUpKeyPath, options: [.new]) { [weak self] (_, _) in
        //hide buffering
    }

    let playbackBufferFullKeyPath = \AVPlayerItem.playbackBufferFull
    playbackBufferFullObserver = playerItem?.observe(playbackBufferFullKeyPath, options: [.new]) { [weak self] (_, _) in
        //hide buffering
    }
}

Beobachter entfernt werden müssen, nachdem wir fertig sind zu beobachten.

Entfernen diese drei Beobachter setzen Sie einfach playbackBufferEmptyObserverplaybackLikelyToKeepUpKeyPathObserver und playbackBufferFullObserver zu nil.

Keine Notwendigkeit, Sie manuell zu entfernen (dies ist spezifisch für observe<Value>(_ keyPath:, options:, changeHandler:) Methode.

InformationsquelleAutor der Antwort Roman Barzyczak

#Aktualisiert Swift 4 und fein gearbeitet

Durch die ich gegangen bin mit der akzeptierten Antwort aber hat nicht funktioniert in swift 4 für mich so nach einiger Suche habe ich gefunden dieser denkt von apple doc. Es gibt zwei Wege, um festzustellen, AVPlayer Staaten,

addPeriodicTimeObserverForInterval:queue:usingBlock: und
addBoundaryTimeObserverForTimes:queue:usingBlock:

und mit Möglichkeiten, wie diese

var observer:Any?
var avplayer : AVPlayer?

func preriodicTimeObsever(){

        if let observer = self.observer{
            //removing time obse
            avplayer?.removeTimeObserver(observer)
            observer = nil
        }

        let intervel : CMTime = CMTimeMake(1, 10)
        observer = avplayer?.addPeriodicTimeObserver(forInterval: intervel, queue: DispatchQueue.main) { [weak self] time in

            guard let strongSelf = self else {return}

            let sliderValue : Float64 = CMTimeGetSeconds(time)
           //this is the slider value update if you are using UISlider.

            let playbackLikelyToKeepUp = strongSelf.avPlayer?.currentItem?.isPlaybackLikelyToKeepUp
            if playbackLikelyToKeepUp == false{

               //Here start the activity indicator inorder to show buffering
            }else{
                //stop the activity indicator 
            }
        }
    }

Und vergessen Sie nicht, Zeit zu töten, Beobachter zu speichern, aus dem memory leak. Methode für das töten von Instanz, fügen Sie diese Methode nach Ihrem Bedarf, aber ich habe es in viewWillDisappear Methode.

       if let observer = self.observer{

            self.avPlayer?.removeTimeObserver(observer)
            observer = nil
        }

InformationsquelleAutor der Antwort Amrit Tiwari

Aktualisiert Swift 4.2

    var player : AVPlayer? = nil

    let videoUrl = URL(string: "https://wolverine.raywenderlich.com/content/ios/tutorials/video_streaming/foxVillage.mp4")
    self.player = AVPlayer(url: videoUrl!)
    self.player?.addPeriodicTimeObserver(forInterval: CMTimeMake(value: 1, timescale: 600), queue: DispatchQueue.main, using: { time in

        if self.player?.currentItem?.status == AVPlayerItem.Status.readyToPlay {

            if let isPlaybackLikelyToKeepUp = self.player?.currentItem?.isPlaybackLikelyToKeepUp {
                //do what ever you want with isPlaybackLikelyToKeepUp value, for example, show or hide a activity indicator.

                //MBProgressHUD.hide(for: self.view, animated: true)
            }
        }
    })

InformationsquelleAutor der Antwort xuzepei

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.