zkit-ui 2.0.3 → 2.0.5

package/ios/GalleryViewer/GaleriaLayoutSupport.swift

@@ -0,0 +1,143 @@
+import UIKit
+
+struct GaleriaSharedElementGeometry {
+    let visibleFrameInWindow: CGRect
+    let contentFrameInVisibleBounds: CGRect
+    let cornerRadius: CGFloat
+}
+
+struct GaleriaSharedElementState {
+    let image: UIImage
+    let geometry: GaleriaSharedElementGeometry
+}
+
+extension CGRect {
+    func galeriaPixelAligned(scale: CGFloat) -> CGRect {
+        guard scale > 0 else { return self }
+        return CGRect(
+            x: (origin.x * scale).rounded() / scale,
+            y: (origin.y * scale).rounded() / scale,
+            width: (size.width * scale).rounded() / scale,
+            height: (size.height * scale).rounded() / scale
+        )
+    }
+
+    func galeriaApproximatelyEquals(_ other: CGRect, tolerance: CGFloat = 0.5) -> Bool {
+        abs(minX - other.minX) <= tolerance
+            && abs(minY - other.minY) <= tolerance
+            && abs(width - other.width) <= tolerance
+            && abs(height - other.height) <= tolerance
+    }
+}
+
+extension GaleriaSharedElementGeometry {
+    func galeriaPixelAligned(scale: CGFloat) -> GaleriaSharedElementGeometry {
+        GaleriaSharedElementGeometry(
+            visibleFrameInWindow: visibleFrameInWindow.galeriaPixelAligned(scale: scale),
+            contentFrameInVisibleBounds: contentFrameInVisibleBounds.galeriaPixelAligned(scale: scale),
+            cornerRadius: (cornerRadius * scale).rounded() / scale
+        )
+    }
+
+    func approximatelyEquals(_ other: GaleriaSharedElementGeometry, tolerance: CGFloat = 0.5) -> Bool {
+        visibleFrameInWindow.galeriaApproximatelyEquals(other.visibleFrameInWindow, tolerance: tolerance)
+            && contentFrameInVisibleBounds.galeriaApproximatelyEquals(
+                other.contentFrameInVisibleBounds,
+                tolerance: tolerance
+            )
+            && abs(cornerRadius - other.cornerRadius) <= tolerance
+    }
+}
+
+extension GaleriaSharedElementState {
+    func approximatelyEquals(_ other: GaleriaSharedElementState, tolerance: CGFloat = 0.5) -> Bool {
+        geometry.approximatelyEquals(other.geometry, tolerance: tolerance)
+            && abs(image.size.width - other.image.size.width) <= tolerance
+            && abs(image.size.height - other.image.size.height) <= tolerance
+    }
+}
+
+extension UIView {
+    func pinToSuperviewEdges(
+        top: CGFloat = 0,
+        leading: CGFloat = 0,
+        trailing: CGFloat = 0,
+        bottom: CGFloat = 0
+    ) {
+        guard let superview = superview else { return }
+        translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            topAnchor.constraint(equalTo: superview.topAnchor, constant: top),
+            leadingAnchor.constraint(equalTo: superview.leadingAnchor, constant: leading),
+            trailingAnchor.constraint(equalTo: superview.trailingAnchor, constant: -trailing),
+            bottomAnchor.constraint(equalTo: superview.bottomAnchor, constant: -bottom),
+        ])
+    }
+
+    func pinToSuperviewEdges(inset: CGFloat) {
+        pinToSuperviewEdges(top: inset, leading: inset, trailing: inset, bottom: inset)
+    }
+
+    func frameInWindow() -> CGRect {
+        convert(bounds, to: nil)
+    }
+}
+
+extension UIImageView {
+    func imageContentFrameInWindow() -> CGRect {
+        guard let image = image else { return frameInWindow() }
+        guard image.size.width > 0, image.size.height > 0 else { return frameInWindow() }
+        guard bounds.width > 0, bounds.height > 0 else { return frameInWindow() }
+
+        let widthRatio = bounds.width / image.size.width
+        let heightRatio = bounds.height / image.size.height
+
+        let scale: CGFloat
+        switch contentMode {
+        case .scaleAspectFill:
+            scale = max(widthRatio, heightRatio)
+        default:
+            scale = min(widthRatio, heightRatio)
+        }
+
+        let contentSize = CGSize(
+            width: image.size.width * scale,
+            height: image.size.height * scale
+        )
+        let contentFrame = CGRect(
+            x: (bounds.width - contentSize.width) * 0.5,
+            y: (bounds.height - contentSize.height) * 0.5,
+            width: contentSize.width,
+            height: contentSize.height
+        )
+        return convert(contentFrame, to: nil)
+    }
+
+    func galeriaSharedElementState(clippingFrameInWindow: CGRect? = nil) -> GaleriaSharedElementState? {
+        guard let image = image else { return nil }
+        guard image.size.width > 0, image.size.height > 0 else { return nil }
+
+        let clippingFrame = clippingFrameInWindow ?? frameInWindow()
+        guard clippingFrame.width > 0, clippingFrame.height > 0 else { return nil }
+
+        let contentFrame = imageContentFrameInWindow()
+        var visibleFrame = clippingFrame.intersection(contentFrame)
+        if visibleFrame.isNull || visibleFrame.isEmpty {
+            visibleFrame = clippingFrame
+        }
+
+        let geometry = GaleriaSharedElementGeometry(
+            visibleFrameInWindow: visibleFrame,
+            contentFrameInVisibleBounds: contentFrame.offsetBy(
+                dx: -visibleFrame.minX,
+                dy: -visibleFrame.minY
+            ),
+            cornerRadius: (clipsToBounds || layer.masksToBounds) ? layer.cornerRadius : 0
+        )
+        let scale = window?.screen.scale ?? UIScreen.main.scale
+        return GaleriaSharedElementState(
+            image: image,
+            geometry: geometry.galeriaPixelAligned(scale: scale)
+        )
+    }
+}

package/ios/GalleryViewer/GaleriaMedia.swift

@@ -0,0 +1,28 @@
+import UIKit
+
+public enum GaleriaMediaItem {
+    case image(UIImage?)
+    case imageURL(URL, placeholder: UIImage?)
+    case video(url: URL, poster: URL?)
+}
+
+public protocol GaleriaDataSource: AnyObject {
+    func numberOfItems() -> Int
+    func item(at index: Int) -> GaleriaMediaItem
+}
+
+public final class GaleriaArrayDataSource: GaleriaDataSource {
+    private let items: [GaleriaMediaItem]
+
+    public init(items: [GaleriaMediaItem]) {
+        self.items = items
+    }
+
+    public func numberOfItems() -> Int {
+        items.count
+    }
+
+    public func item(at index: Int) -> GaleriaMediaItem {
+        items[index]
+    }
+}

package/ios/GalleryViewer/GaleriaSourceViewRegistry.swift

@@ -0,0 +1,80 @@
+import UIKit
+
+final class GaleriaSourceViewRegistry {
+    static let shared = GaleriaSourceViewRegistry()
+
+    private final class WeakImageView {
+        weak var value: UIImageView?
+
+        init(_ value: UIImageView) {
+            self.value = value
+        }
+    }
+
+    private var anchors: [String: [Int: WeakImageView]] = [:]
+
+    private init() {}
+
+    func register(_ imageView: UIImageView, galleryId: String, index: Int) {
+        cleanup()
+        var galleryAnchors = anchors[galleryId] ?? [:]
+        galleryAnchors[index] = WeakImageView(imageView)
+        anchors[galleryId] = galleryAnchors
+    }
+
+    func unregister(_ imageView: UIImageView, galleryId: String?, index: Int?) {
+        cleanup()
+        if let galleryId = galleryId {
+            remove(imageView, from: galleryId, index: index)
+        } else {
+            for galleryId in Array(anchors.keys) {
+                remove(imageView, from: galleryId, index: nil)
+            }
+        }
+        cleanup()
+    }
+
+    func sourceView(for galleryId: String, index: Int) -> UIImageView? {
+        cleanup()
+        guard
+            let imageView = anchors[galleryId]?[index]?.value,
+            let window = imageView.window,
+            !imageView.isHidden
+        else {
+            return nil
+        }
+
+        let frameInWindow = imageView.frameInWindow()
+        guard !frameInWindow.isEmpty, frameInWindow.intersects(window.bounds) else {
+            return nil
+        }
+
+        return imageView
+    }
+
+    private func remove(_ imageView: UIImageView, from galleryId: String, index: Int?) {
+        guard var galleryAnchors = anchors[galleryId] else { return }
+
+        if let index = index {
+            if let registeredView = galleryAnchors[index]?.value, registeredView === imageView {
+                galleryAnchors.removeValue(forKey: index)
+            }
+        } else {
+            galleryAnchors = galleryAnchors.filter { _, weakImageView in
+                guard let registeredView = weakImageView.value else { return false }
+                return registeredView !== imageView
+            }
+        }
+
+        anchors[galleryId] = galleryAnchors.isEmpty ? nil : galleryAnchors
+    }
+
+    private func cleanup() {
+        anchors = anchors.compactMapValues { galleryAnchors in
+            let activeAnchors = galleryAnchors.filter { _, weakImageView in
+                weakImageView.value != nil
+            }
+            return activeAnchors.isEmpty ? nil : activeAnchors
+        }
+    }
+}

package/ios/GalleryViewer/GaleriaVideoPlayerView.swift

@@ -0,0 +1,437 @@
+import AVFoundation
+import UIKit
+
+final class GaleriaVideoPlayerView: UIView {
+    private var player: AVPlayer?
+    private var playerLayer: AVPlayerLayer?
+    private var timeObserver: Any?
+    private var endObserver: NSObjectProtocol?
+    private var readyForDisplayObservation: NSKeyValueObservation?
+    private var itemStatusObservation: NSKeyValueObservation?
+    private var likelyToKeepUpObservation: NSKeyValueObservation?
+    private var bufferFullObservation: NSKeyValueObservation?
+    private var playbackGeneration = 0
+    private var isScrubbing = false
+    private var wasPlayingBeforeScrub = false
+    private var hasReportedFirstFrame = false
+    private var isPrimingFirstFrame = false
+    private var controlsVisible = false
+    private var controlsContainerConstraints: [NSLayoutConstraint] = []
+
+    private let playButton = UIButton(type: .system)
+    private let slider = UISlider()
+    private let timeLabel = UILabel()
+    private let controlsContainer = UIView()
+
+    var onControlsInteractStart: (() -> Void)?
+    var onControlsInteractEnd: (() -> Void)?
+    var onFirstFrameReady: (() -> Void)?
+
+    var url: URL? {
+        didSet {
+            setupPlayer()
+        }
+    }
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupUI()
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        playerLayer?.frame = bounds
+    }
+
+    deinit {
+        tearDownPlayer()
+    }
+
+    func toggleControls() {
+        setControlsVisible(!controlsVisible, animated: true)
+    }
+
+    func resetToStart() {
+        player?.pause()
+        player?.seek(to: .zero, toleranceBefore: .zero, toleranceAfter: .zero)
+        slider.value = 0
+        updateTimeLabel(current: 0, duration: CMTimeGetSeconds(player?.currentItem?.duration ?? .zero))
+        updatePlayButton(isPlaying: false)
+    }
+
+    func play() {
+        if hasReportedFirstFrame == false {
+            primeFirstFrameIfNeeded()
+        }
+        player?.isMuted = false
+        player?.play()
+        updatePlayButton(isPlaying: true)
+    }
+
+    func pause() {
+        player?.pause()
+        if hasReportedFirstFrame == false {
+            isPrimingFirstFrame = false
+        }
+        updatePlayButton(isPlaying: false)
+    }
+
+    func setPlayerVisible(_ visible: Bool) {
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        playerLayer?.frame = bounds
+        playerLayer?.isHidden = !visible
+        playerLayer?.opacity = visible ? 1 : 0
+        CATransaction.commit()
+        if visible {
+            setNeedsLayout()
+            layoutIfNeeded()
+        }
+    }
+
+    func attachControls(to hostView: UIView) {
+        if controlsContainer.superview === hostView {
+            hostView.bringSubviewToFront(controlsContainer)
+            return
+        }
+
+        NSLayoutConstraint.deactivate(controlsContainerConstraints)
+        controlsContainer.removeFromSuperview()
+        hostView.addSubview(controlsContainer)
+        controlsContainer.translatesAutoresizingMaskIntoConstraints = false
+        controlsContainerConstraints = [
+            controlsContainer.bottomAnchor.constraint(equalTo: hostView.safeAreaLayoutGuide.bottomAnchor, constant: -20),
+            controlsContainer.leadingAnchor.constraint(equalTo: hostView.leadingAnchor, constant: 12),
+            controlsContainer.trailingAnchor.constraint(equalTo: hostView.trailingAnchor, constant: -12),
+            controlsContainer.heightAnchor.constraint(equalToConstant: 56),
+        ]
+        NSLayoutConstraint.activate(controlsContainerConstraints)
+        hostView.bringSubviewToFront(controlsContainer)
+    }
+
+    func setControlsVisible(_ visible: Bool, animated: Bool) {
+        controlsVisible = visible
+        let animations = {
+            self.controlsContainer.alpha = visible ? 1 : 0
+        }
+        let completion: (Bool) -> Void = { _ in
+            self.controlsContainer.isUserInteractionEnabled = visible
+        }
+
+        if animated {
+            UIView.animate(
+                withDuration: 0.22,
+                delay: 0,
+                options: [.curveEaseInOut, .beginFromCurrentState],
+                animations: animations,
+                completion: completion
+            )
+        } else {
+            animations()
+            completion(true)
+        }
+    }
+
+    func isTouchOnInteractiveControls(atWindowPoint point: CGPoint) -> Bool {
+        return expandedFrameForInteraction(of: controlsContainer, padding: 20)?.contains(point) == true
+    }
+
+    func isPointInsideInteractiveControls(_ point: CGPoint) -> Bool {
+        guard controlsVisible else { return false }
+        guard let hostView = controlsContainer.superview else { return false }
+        let pointInHost = hostView.convert(point, from: self)
+        if controlsContainer.frame.insetBy(dx: -20, dy: -20).contains(pointInHost) {
+            return true
+        }
+        return false
+    }
+
+    func primeFirstFrameIfNeeded() {
+        guard let player = player else { return }
+        guard hasReportedFirstFrame == false, isPrimingFirstFrame == false else { return }
+        isPrimingFirstFrame = true
+        player.isMuted = true
+        player.play()
+    }
+
+    func resetForReuse() {
+        setControlsVisible(false, animated: false)
+        url = nil
+    }
+
+    private func setupUI() {
+        backgroundColor = .clear
+
+        controlsContainer.backgroundColor = UIColor.black.withAlphaComponent(0.5)
+        controlsContainer.layer.cornerRadius = 12
+        controlsContainer.translatesAutoresizingMaskIntoConstraints = false
+        controlsContainer.alpha = 0
+
+        playButton.setImage(UIImage(systemName: "play.fill"), for: .normal)
+        playButton.setPreferredSymbolConfiguration(
+            UIImage.SymbolConfiguration(pointSize: 20, weight: .bold),
+            forImageIn: .normal
+        )
+        playButton.tintColor = .white
+        playButton.translatesAutoresizingMaskIntoConstraints = false
+        playButton.addTarget(self, action: #selector(handlePlayButtonTouchDown), for: .touchDown)
+        playButton.addTarget(self, action: #selector(togglePlay), for: .touchUpInside)
+        playButton.addTarget(
+            self,
+            action: #selector(handleControlInteractionEnded),
+            for: [.touchUpInside, .touchUpOutside, .touchCancel]
+        )
+        controlsContainer.addSubview(playButton)
+
+        slider.minimumValue = 0
+        slider.maximumValue = 1
+        slider.value = 0
+        slider.tintColor = .white
+        slider.translatesAutoresizingMaskIntoConstraints = false
+        slider.addTarget(self, action: #selector(sliderValueChanged), for: .valueChanged)
+        slider.addTarget(self, action: #selector(handleSliderTouchDown), for: .touchDown)
+        slider.addTarget(self, action: #selector(handleSliderTouchUp), for: [.touchUpInside, .touchUpOutside, .touchCancel])
+        controlsContainer.addSubview(slider)
+
+        timeLabel.textColor = .white
+        timeLabel.font = .systemFont(ofSize: 13, weight: .regular)
+        timeLabel.text = "00:00 / 00:00"
+        timeLabel.translatesAutoresizingMaskIntoConstraints = false
+        controlsContainer.addSubview(timeLabel)
+
+        NSLayoutConstraint.activate([
+            playButton.leadingAnchor.constraint(equalTo: controlsContainer.leadingAnchor, constant: 10),
+            playButton.centerYAnchor.constraint(equalTo: controlsContainer.centerYAnchor),
+            playButton.widthAnchor.constraint(equalToConstant: 44),
+            playButton.heightAnchor.constraint(equalToConstant: 44),
+
+            slider.leadingAnchor.constraint(equalTo: playButton.trailingAnchor, constant: 10),
+            slider.trailingAnchor.constraint(equalTo: timeLabel.leadingAnchor, constant: -10),
+            slider.centerYAnchor.constraint(equalTo: controlsContainer.centerYAnchor),
+
+            timeLabel.trailingAnchor.constraint(equalTo: controlsContainer.trailingAnchor, constant: -12),
+            timeLabel.centerYAnchor.constraint(equalTo: controlsContainer.centerYAnchor),
+        ])
+
+        attachControls(to: self)
+    }
+
+    private func setupPlayer() {
+        playbackGeneration += 1
+        let generation = playbackGeneration
+        tearDownPlayer()
+        guard let url = url else { return }
+
+        let item = AVPlayerItem(url: url)
+        player = AVPlayer(playerItem: item)
+        playerLayer = AVPlayerLayer(player: player)
+        playerLayer?.videoGravity = .resizeAspect
+        if let playerLayer = playerLayer {
+            layer.insertSublayer(playerLayer, at: 0)
+        }
+        playerLayer?.isHidden = true
+        player?.pause()
+        player?.isMuted = true
+        player?.seek(to: .zero, toleranceBefore: .zero, toleranceAfter: .zero)
+        hasReportedFirstFrame = false
+        isPrimingFirstFrame = false
+        slider.value = 0
+        updateTimeLabel(current: 0, duration: 0)
+        updatePlayButton(isPlaying: false)
+
+        let notifyFirstFrameReadyIfPossible: () -> Void = { [weak self] in
+            guard let self = self, self.playbackGeneration == generation, self.hasReportedFirstFrame == false else { return }
+            guard let currentItem = self.player?.currentItem else { return }
+            let isReadyToPlay = currentItem.status == .readyToPlay
+            let isLikelyToKeepUp = currentItem.isPlaybackLikelyToKeepUp || currentItem.isPlaybackBufferFull
+            let isReadyForDisplay = self.playerLayer?.isReadyForDisplay == true
+            guard isReadyToPlay, isLikelyToKeepUp, isReadyForDisplay else { return }
+            self.hasReportedFirstFrame = true
+            self.isPrimingFirstFrame = false
+            self.player?.pause()
+            self.player?.seek(to: .zero, toleranceBefore: .zero, toleranceAfter: .zero)
+            self.player?.isMuted = false
+            DispatchQueue.main.async {
+                guard self.playbackGeneration == generation else { return }
+                DispatchQueue.main.async {
+                    guard self.playbackGeneration == generation else { return }
+                    self.onFirstFrameReady?()
+                }
+            }
+        }
+
+        itemStatusObservation = item.observe(\.status, options: [.new, .initial]) { _, _ in
+            notifyFirstFrameReadyIfPossible()
+        }
+        likelyToKeepUpObservation = item.observe(\.isPlaybackLikelyToKeepUp, options: [.new, .initial]) { _, _ in
+            notifyFirstFrameReadyIfPossible()
+        }
+        bufferFullObservation = item.observe(\.isPlaybackBufferFull, options: [.new, .initial]) { _, _ in
+            notifyFirstFrameReadyIfPossible()
+        }
+
+        readyForDisplayObservation = playerLayer?.observe(\.isReadyForDisplay, options: [.new, .initial]) { [weak self] _, change in
+            guard let self = self, self.playbackGeneration == generation, change.newValue == true else {
+                return
+            }
+            notifyFirstFrameReadyIfPossible()
+        }
+
+        timeObserver = player?.addPeriodicTimeObserver(
+            forInterval: CMTime(seconds: 0.5, preferredTimescale: 600),
+            queue: .main
+        ) { [weak self] time in
+            guard let self = self, self.playbackGeneration == generation, let item = self.player?.currentItem else { return }
+            let duration = CMTimeGetSeconds(item.duration)
+            let current = CMTimeGetSeconds(time)
+            if duration.isFinite && duration > 0, !self.isScrubbing {
+                self.slider.value = Float(current / duration)
+            }
+            self.updateTimeLabel(current: current, duration: duration)
+        }
+
+        endObserver = NotificationCenter.default.addObserver(
+            forName: .AVPlayerItemDidPlayToEndTime,
+            object: player?.currentItem,
+            queue: .main
+        ) { [weak self] _ in
+            guard let self = self, self.playbackGeneration == generation else { return }
+            self.resetToStart()
+        }
+    }
+
+    @objc
+    private func togglePlay() {
+        if hasReportedFirstFrame == false {
+            primeFirstFrameIfNeeded()
+        }
+        guard let player = player else { return }
+        if player.timeControlStatus == .playing {
+            player.pause()
+            updatePlayButton(isPlaying: false)
+        } else {
+            player.isMuted = false
+            player.play()
+            updatePlayButton(isPlaying: true)
+        }
+    }
+
+    @objc
+    private func sliderValueChanged() {
+        guard let player = player, let item = player.currentItem else { return }
+        let duration = CMTimeGetSeconds(item.duration)
+        guard duration.isFinite && duration > 0 else { return }
+        let targetTime = Double(slider.value) * duration
+        isScrubbing = true
+        player.seek(
+            to: CMTime(seconds: targetTime, preferredTimescale: 600),
+            toleranceBefore: .zero,
+            toleranceAfter: .zero
+        )
+        updateTimeLabel(current: targetTime, duration: duration)
+    }
+
+    private func formatTime(_ seconds: Double) -> String {
+        guard seconds.isFinite && seconds >= 0 else { return "--:--" }
+        let total = Int(seconds.rounded())
+        return String(format: "%02d:%02d", total / 60, total % 60)
+    }
+
+    private func updateTimeLabel(current: Double, duration: Double) {
+        timeLabel.text = "\(formatTime(current)) / \(formatTime(duration))"
+    }
+
+    private func updatePlayButton(isPlaying: Bool) {
+        playButton.setImage(UIImage(systemName: isPlaying ? "pause.fill" : "play.fill"), for: .normal)
+    }
+
+    private func expandedFrameForInteraction(of view: UIView, padding: CGFloat) -> CGRect? {
+        guard controlsVisible else { return nil }
+        guard view.alpha > 0.01, !view.bounds.isEmpty else { return nil }
+        return view.convert(view.bounds.insetBy(dx: -padding, dy: -padding), to: nil)
+    }
+
+    @objc
+    private func handleSliderTouchDown() {
+        guard let player = player else { return }
+        isScrubbing = true
+        wasPlayingBeforeScrub = player.timeControlStatus == .playing
+        player.pause()
+        onControlsInteractStart?()
+    }
+
+    @objc
+    private func handleSliderTouchUp() {
+        guard let player = player, let item = player.currentItem else {
+            isScrubbing = false
+            onControlsInteractEnd?()
+            return
+        }
+        let duration = CMTimeGetSeconds(item.duration)
+        guard duration.isFinite && duration > 0 else {
+            isScrubbing = false
+            onControlsInteractEnd?()
+            return
+        }
+        let targetTime = Double(slider.value) * duration
+        player.seek(
+            to: CMTime(seconds: targetTime, preferredTimescale: 600),
+            toleranceBefore: .zero,
+            toleranceAfter: .zero
+        ) { [weak self] _ in
+            DispatchQueue.main.async {
+                guard let self = self else { return }
+                self.isScrubbing = false
+                if self.wasPlayingBeforeScrub {
+                    self.play()
+                } else {
+                    self.pause()
+                }
+                self.onControlsInteractEnd?()
+            }
+        }
+    }
+
+    @objc
+    private func handlePlayButtonTouchDown() {
+        onControlsInteractStart?()
+    }
+
+    @objc
+    private func handleControlInteractionEnded() {
+        onControlsInteractEnd?()
+    }
+
+    private func tearDownPlayer() {
+        if let timeObserver = timeObserver, let player = player {
+            player.removeTimeObserver(timeObserver)
+        }
+        if let endObserver = endObserver {
+            NotificationCenter.default.removeObserver(endObserver)
+        }
+        readyForDisplayObservation?.invalidate()
+        itemStatusObservation?.invalidate()
+        likelyToKeepUpObservation?.invalidate()
+        bufferFullObservation?.invalidate()
+        readyForDisplayObservation = nil
+        itemStatusObservation = nil
+        likelyToKeepUpObservation = nil
+        bufferFullObservation = nil
+        timeObserver = nil
+        endObserver = nil
+
+        player?.pause()
+        player = nil
+        playerLayer?.removeFromSuperlayer()
+        playerLayer = nil
+
+        isScrubbing = false
+        wasPlayingBeforeScrub = false
+        hasReportedFirstFrame = false
+        isPrimingFirstFrame = false
+    }
+}