How to detect when AVPlayer video ends playing?

AVPlayer

video playback

detect video end

iOS development

Swift programming

How to detect when AVPlayer video ends playing?

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions

iOS & Android

Introduction

Detecting when an AVPlayer video finishes playing requires observing the .AVPlayerItemDidPlayToEndTime notification on the AVPlayerItem. This notification fires when the player reaches the end of the item's duration. Alternative approaches include using Key-Value Observing (KVO) on the player item's status property and adding a boundary time observer. For looping video, seek back to the beginning in the notification handler. This article covers all approaches in both UIKit and SwiftUI.

Using NotificationCenter

swift

1import AVFoundation
2import UIKit
3
4class VideoPlayerVC: UIViewController {
5    var player: AVPlayer!
6
7    override func viewDidLoad() {
8        super.viewDidLoad()
9
10        let url = URL(string: "https://example.com/video.mp4")!
11        let playerItem = AVPlayerItem(url: url)
12        player = AVPlayer(playerItem: playerItem)
13
14        // Observe end-of-playback notification
15        NotificationCenter.default.addObserver(
16            self,
17            selector: #selector(videoDidEnd),
18            name: .AVPlayerItemDidPlayToEndTime,
19            object: playerItem  // Observe this specific item
20        )
21
22        player.play()
23    }
24
25    @objc func videoDidEnd(_ notification: Notification) {
26        print("Video finished playing")
27        // Navigate to next screen, show replay button, etc.
28    }
29
30    deinit {
31        NotificationCenter.default.removeObserver(self)
32    }
33}

Pass the playerItem as the object parameter to receive notifications only for that specific item. Passing nil receives notifications from all player items.

Using Closure-Based Observer

swift

1class VideoPlayerVC: UIViewController {
2    var player: AVPlayer!
3    var endObserver: NSObjectProtocol?
4
5    override func viewDidLoad() {
6        super.viewDidLoad()
7
8        let playerItem = AVPlayerItem(url: videoURL)
9        player = AVPlayer(playerItem: playerItem)
10
11        // Closure-based observation — no @objc required
12        endObserver = NotificationCenter.default.addObserver(
13            forName: .AVPlayerItemDidPlayToEndTime,
14            object: playerItem,
15            queue: .main
16        ) { [weak self] _ in
17            guard let self = self else { return }
18            self.handleVideoEnd()
19        }
20
21        player.play()
22    }
23
24    func handleVideoEnd() {
25        print("Video ended")
26    }
27
28    deinit {
29        if let observer = endObserver {
30            NotificationCenter.default.removeObserver(observer)
31        }
32    }
33}

The closure-based API returns a token that must be retained and removed in deinit. Use [weak self] to avoid retain cycles.

Looping Video (Replay on End)

swift

1class LoopingVideoVC: UIViewController {
2    var player: AVPlayer!
3
4    override func viewDidLoad() {
5        super.viewDidLoad()
6
7        let playerItem = AVPlayerItem(url: videoURL)
8        player = AVPlayer(playerItem: playerItem)
9
10        NotificationCenter.default.addObserver(
11            self,
12            selector: #selector(loopVideo),
13            name: .AVPlayerItemDidPlayToEndTime,
14            object: playerItem
15        )
16
17        player.play()
18    }
19
20    @objc func loopVideo(_ notification: Notification) {
21        player.seek(to: .zero)
22        player.play()
23    }
24}
25
26// Alternative: AVPlayerLooper (iOS 10+) for seamless looping
27class SeamlessLoopVC: UIViewController {
28    var player: AVQueuePlayer!
29    var looper: AVPlayerLooper!
30
31    override func viewDidLoad() {
32        super.viewDidLoad()
33
34        let item = AVPlayerItem(url: videoURL)
35        player = AVQueuePlayer(items: [item])
36        looper = AVPlayerLooper(player: player, templateItem: item)
37
38        player.play()
39        // Loops automatically — no notification needed
40    }
41}

AVPlayerLooper provides gapless looping without manual seek. For simple loop-on-end, seeking to .zero in the notification handler works but may have a brief gap.

Detecting Playback Failure

swift

1// Also observe when playback fails
2NotificationCenter.default.addObserver(
3    self,
4    selector: #selector(videoDidFail),
5    name: .AVPlayerItemFailedToPlayToEndTime,
6    object: playerItem
7)
8
9@objc func videoDidFail(_ notification: Notification) {
10    if let error = notification.userInfo?[AVPlayerItemFailedToPlayToEndTimeErrorKey] as? Error {
11        print("Playback failed: \(error.localizedDescription)")
12    }
13}

.AVPlayerItemFailedToPlayToEndTime fires when playback is interrupted by an error (network failure, corrupted file). Always observe both notifications for robust error handling.

Boundary Time Observer

swift

1// Fire a callback at a specific time (e.g., 5 seconds before end)
2let duration = playerItem.asset.duration
3let fiveSecondsBeforeEnd = CMTimeSubtract(duration, CMTime(seconds: 5, preferredTimescale: 600))
4
5let boundaryObserver = player.addBoundaryTimeObserver(
6    forTimes: [NSValue(time: fiveSecondsBeforeEnd)],
7    queue: .main
8) {
9    print("5 seconds until video ends — show skip button")
10}
11
12// Remove when done
13player.removeTimeObserver(boundaryObserver)

Boundary time observers fire when playback passes specific timestamps. Use this for pre-end actions like showing UI elements before the video finishes.

SwiftUI Integration

swift

1import SwiftUI
2import AVKit
3
4struct VideoPlayerView: View {
5    @State private var player = AVPlayer(url: URL(string: "https://example.com/video.mp4")!)
6    @State private var videoEnded = false
7
8    var body: some View {
9        VStack {
10            VideoPlayer(player: player)
11                .onAppear {
12                    setupEndObserver()
13                    player.play()
14                }
15                .frame(height: 300)
16
17            if videoEnded {
18                Button("Replay") {
19                    player.seek(to: .zero)
20                    player.play()
21                    videoEnded = false
22                }
23            }
24        }
25    }
26
27    func setupEndObserver() {
28        NotificationCenter.default.addObserver(
29            forName: .AVPlayerItemDidPlayToEndTime,
30            object: player.currentItem,
31            queue: .main
32        ) { _ in
33            videoEnded = true
34        }
35    }
36}

Periodic Time Observer (Progress Tracking)

swift

1// Track playback progress and detect near-end
2let interval = CMTime(seconds: 0.5, preferredTimescale: 600)
3
4let timeObserver = player.addPeriodicTimeObserver(
5    forInterval: interval,
6    queue: .main
7) { time in
8    let currentSeconds = CMTimeGetSeconds(time)
9    let duration = CMTimeGetSeconds(player.currentItem?.duration ?? .zero)
10
11    let progress = currentSeconds / duration
12    print("Progress: \(Int(progress * 100))%")
13
14    if duration - currentSeconds < 1.0 {
15        print("Almost done!")
16    }
17}

Periodic time observers provide continuous progress updates. Use them for progress bars, time labels, and detecting when playback is near the end.

Common Pitfalls

Not removing observers in deinit: Failing to remove notification observers causes crashes if the notification fires after the view controller is deallocated. Always remove in deinit or use [weak self] with closure observers.
Passing nil for the notification object: addObserver(... object: nil) receives notifications from all AVPlayerItem instances. If your app has multiple players, you receive duplicate callbacks. Always pass the specific playerItem.
Notification not firing for streaming content: If a stream has no defined end (live stream), .AVPlayerItemDidPlayToEndTime never fires. Check playerItem.duration — live streams have .indefinite duration.
Seek to zero not working for loop: player.seek(to: .zero) is asynchronous. If you call player.play() before the seek completes, playback may stutter. Use the completion handler: player.seek(to: .zero) { _ in player.play() }.
Ignoring AVPlayerItemFailedToPlayToEndTime: Only observing the success notification misses playback errors. Always observe both .AVPlayerItemDidPlayToEndTime and .AVPlayerItemFailedToPlayToEndTime.

Summary

Observe .AVPlayerItemDidPlayToEndTime notification to detect when a video finishes
Always pass the specific playerItem as the observation object, not nil
Use AVPlayerLooper for seamless gapless looping on iOS 10+
Use boundary time observers to trigger actions at specific timestamps before the end
Remove all observers in deinit to prevent crashes
Observe .AVPlayerItemFailedToPlayToEndTime for error handling

Tackling System Design Interview Problems

A short course that equips you with the skills to approach system design interviews methodically.

Start the free course

Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions

How to detect when AVPlayer video ends playing?

Interview Questions practice on Codemia

Introduction

Using NotificationCenter

Using Closure-Based Observer

Looping Video (Replay on End)

Detecting Playback Failure

Boundary Time Observer

SwiftUI Integration

Periodic Time Observer (Progress Tracking)

Common Pitfalls

Summary

Related reading

Tackling System Design Interview Problems

Track what you have practised

Interview Questions practice on Codemia