@neoskola/auto-play 0.3.7 → 0.3.9

package/ios/hybrid/HybridAutoPlay.swift

@@ -188,6 +188,13 @@ class HybridAutoPlay: HybridAutoPlaySpec {
                     )
                 }
 
+                // NowPlayingTemplate: inject custom UIKit view into CPWindow
+                if let nowPlaying = template as? NowPlayingTemplate {
+                    try await MainActor.run {
+                        try nowPlaying.injectCustomView()
+                    }
+                }
+
                 if let autoDismissMs = TemplateStore.getTemplate(
                     templateId: templateId
                 )?.autoDismissMs {

package/ios/templates/NowPlayingTemplate.swift

@@ -2,14 +2,18 @@ import CarPlay
 import MediaPlayer
 import AVFoundation
 
-class NowPlayingTemplate: AutoPlayTemplate {
-    var template: CPListTemplate
+class NowPlayingTemplate: NSObject, AutoPlayTemplate, CPMapTemplateDelegate, NowPlayingViewDelegate {
+    var template: CPMapTemplate
     var config: NowPlayingTemplateConfig
     private var loadedImage: UIImage?
     private var isSetupComplete = false
     private var currentElapsedTime: Double = 0
     private var currentDuration: Double = 0
 
+    // Custom UIKit view
+    private var customViewController: NeoSkolaNowPlayingViewController?
+    private var previousRootVC: UIViewController?
+
     // Native audio player
     private var player: AVPlayer?
     private var playerItem: AVPlayerItem?
@@ -33,75 +37,12 @@ class NowPlayingTemplate: AutoPlayTemplate {
 
     init(config: NowPlayingTemplateConfig) {
         self.config = config
+        template = CPMapTemplate(id: config.id)
 
-        let titleText = Parser.parseText(text: config.title) ?? "Now Playing"
-        let subtitleText = config.subtitle.flatMap { Parser.parseText(text: $0) } ?? ""
+        super.init()
 
-        // Section 1: Bilgi — ders ve kurs adi
-        let infoItem = CPListItem(
-            text: titleText,
-            detailText: subtitleText,
-            image: UIImage(systemName: "music.note"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-        let infoSection = CPListSection(
-            items: [infoItem],
-            header: "Şimdi Oynatılıyor",
-            sectionIndexTitle: nil
-        )
-
-        // Section 2: Sure bilgisi
-        let timeItem = CPListItem(
-            text: "Yükleniyor...",
-            detailText: nil,
-            image: UIImage(systemName: "clock"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-        let timeSection = CPListSection(
-            items: [timeItem],
-            header: nil,
-            sectionIndexTitle: nil
-        )
-
-        // Section 3: Kontroller — onceki, oynat/duraklat, sonraki
-        let prevItem = CPListItem(
-            text: "Önceki Bölüm",
-            detailText: nil,
-            image: UIImage(systemName: "backward.end.fill"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-        let playPauseItem = CPListItem(
-            text: "Oynat",
-            detailText: nil,
-            image: UIImage(systemName: "play.circle.fill"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-        let nextItem = CPListItem(
-            text: "Sonraki Bölüm",
-            detailText: nil,
-            image: UIImage(systemName: "forward.end.fill"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-        let controlSection = CPListSection(
-            items: [prevItem, playPauseItem, nextItem],
-            header: nil,
-            sectionIndexTitle: nil
-        )
-
-        template = CPListTemplate(
-            title: "Now Playing",
-            sections: [infoSection, timeSection, controlSection],
-            assistantCellConfiguration: nil,
-            id: config.id
-        )
-
-        // Handler'lari ayarla
-        setupListItemHandlers(prevItem: prevItem, playPauseItem: playPauseItem, nextItem: nextItem)
+        template.mapDelegate = self
+        template.mapButtons = []
 
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
@@ -116,122 +57,81 @@ class NowPlayingTemplate: AutoPlayTemplate {
         }
     }
 
-    // MARK: - List Item Handlers
+    // MARK: - Custom View Injection
 
-    private func setupListItemHandlers(prevItem: CPListItem, playPauseItem: CPListItem, nextItem: CPListItem) {
-        prevItem.handler = { [weak self] _, completion in
-            self?.config.onPreviousTrack?()
-            completion()
-        }
-
-        playPauseItem.handler = { [weak self] _, completion in
-            DispatchQueue.main.async {
-                guard let self = self else { completion(); return }
-                if self.config.isPlaying {
-                    self.pauseAudio()
-                    self.config.onPause?()
-                } else {
-                    self.resumeAudio()
-                    self.config.onPlay?()
-                }
-                completion()
-            }
+    @MainActor
+    func injectCustomView() throws {
+        guard let scene = SceneStore.getRootScene(),
+              let window = scene.window else {
+            throw AutoPlayError.noUiWindow("NowPlaying: window nil")
         }
 
-        nextItem.handler = { [weak self] _, completion in
-            self?.config.onNextTrack?()
-            completion()
+        previousRootVC = window.rootViewController
+
+        let customVC = NeoSkolaNowPlayingViewController()
+        customVC.delegate = self
+
+        let titleText = Parser.parseText(text: config.title) ?? "Now Playing"
+        let subtitleText = config.subtitle.flatMap { Parser.parseText(text: $0) } ?? ""
+        customVC.updateInfo(courseName: subtitleText, lessonName: titleText)
+        customVC.updatePlaybackState(isPlaying: config.isPlaying)
+
+        if let loadedImage = loadedImage {
+            customVC.updateArtwork(image: loadedImage)
         }
+
+        window.rootViewController = customVC
+        window.makeKeyAndVisible()
+
+        self.customViewController = customVC
+    }
+
+    @MainActor
+    private func restoreOriginalView() {
+        guard let scene = SceneStore.getRootScene(),
+              let window = scene.window else { return }
+
+        if let previousRootVC = previousRootVC {
+            window.rootViewController = previousRootVC
+            window.makeKeyAndVisible()
+        }
+        self.previousRootVC = nil
+        self.customViewController = nil
+    }
+
+    // MARK: - NowPlayingViewDelegate
+
+    func didTapPlayPause() {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            if self.config.isPlaying {
+                self.pauseAudio()
+                self.config.onPause?()
+            } else {
+                self.resumeAudio()
+                self.config.onPlay?()
+            }
+        }
+    }
+
+    func didTapPrevious() {
+        config.onPreviousTrack?()
+    }
+
+    func didTapNext() {
+        config.onNextTrack?()
     }
 
     // MARK: - Player UI
 
     private func updatePlayerUI() {
-        let titleText = Parser.parseText(text: config.title) ?? "Now Playing"
-        let subtitleText = config.subtitle.flatMap { Parser.parseText(text: $0) } ?? ""
+        guard let customVC = customViewController else { return }
 
-        // Section 1: Bilgi
-        let infoItem = CPListItem(
-            text: titleText,
-            detailText: subtitleText,
-            image: loadedImage ?? UIImage(systemName: "music.note"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-        let infoSection = CPListSection(
-            items: [infoItem],
-            header: "Şimdi Oynatılıyor",
-            sectionIndexTitle: nil
-        )
-
-        // Section 2: Sure
-        let elapsed = formatTime(currentElapsedTime)
-        let total = currentDuration > 0 ? formatTime(currentDuration) : "--:--"
-        let timeText: String
-        let timeIcon: String
-        if config.isPlaying {
-            timeText = "\(elapsed) / \(total)"
-            timeIcon = "waveform"
-        } else {
-            timeText = "Duraklatıldı  \(elapsed) / \(total)"
-            timeIcon = "pause.circle"
-        }
-        let timeItem = CPListItem(
-            text: timeText,
-            detailText: nil,
-            image: UIImage(systemName: timeIcon),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-        let timeSection = CPListSection(
-            items: [timeItem],
-            header: nil,
-            sectionIndexTitle: nil
-        )
-
-        // Section 3: Kontroller
-        let prevItem = CPListItem(
-            text: "Önceki Bölüm",
-            detailText: nil,
-            image: UIImage(systemName: "backward.end.fill"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-
-        let playPauseText = config.isPlaying ? "Duraklat" : "Oynat"
-        let playPauseIcon = config.isPlaying ? "pause.circle.fill" : "play.circle.fill"
-        let playPauseItem = CPListItem(
-            text: playPauseText,
-            detailText: nil,
-            image: UIImage(systemName: playPauseIcon),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-
-        let nextItem = CPListItem(
-            text: "Sonraki Bölüm",
-            detailText: nil,
-            image: UIImage(systemName: "forward.end.fill"),
-            accessoryImage: nil,
-            accessoryType: .none
-        )
-
-        setupListItemHandlers(prevItem: prevItem, playPauseItem: playPauseItem, nextItem: nextItem)
-
-        let controlSection = CPListSection(
-            items: [prevItem, playPauseItem, nextItem],
-            header: nil,
-            sectionIndexTitle: nil
-        )
-
-        template.updateSections([infoSection, timeSection, controlSection])
-    }
-
-    private func formatTime(_ seconds: Double) -> String {
-        guard !seconds.isNaN && !seconds.isInfinite && seconds >= 0 else { return "0:00" }
-        let mins = Int(seconds) / 60
-        let secs = Int(seconds) % 60
-        return String(format: "%d:%02d", mins, secs)
+        let titleText = Parser.parseText(text: config.title) ?? ""
+        let subtitleText = config.subtitle.flatMap { Parser.parseText(text: $0) } ?? ""
+        customVC.updateInfo(courseName: subtitleText, lessonName: titleText)
+        customVC.updatePlaybackState(isPlaying: config.isPlaying)
+        customVC.updateTime(elapsed: currentElapsedTime, duration: currentDuration)
     }
 
     // MARK: - Native Audio Playback
@@ -380,7 +280,6 @@ class NowPlayingTemplate: AutoPlayTemplate {
         nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = config.isPlaying ? 1.0 : 0.0
         MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
 
-        // Update custom player UI
         updatePlayerUI()
 
         // 95% completion check
@@ -540,7 +439,6 @@ class NowPlayingTemplate: AutoPlayTemplate {
             return .success
         }
 
-        // Sonraki bolum
         commandCenter.nextTrackCommand.isEnabled = true
         commandCenter.nextTrackCommand.removeTarget(nil)
         commandCenter.nextTrackCommand.addTarget { [weak self] _ in
@@ -548,7 +446,6 @@ class NowPlayingTemplate: AutoPlayTemplate {
             return .success
         }
 
-        // Onceki bolum
         commandCenter.previousTrackCommand.isEnabled = true
         commandCenter.previousTrackCommand.removeTarget(nil)
         commandCenter.previousTrackCommand.addTarget { [weak self] _ in
@@ -583,7 +480,7 @@ class NowPlayingTemplate: AutoPlayTemplate {
                 DispatchQueue.main.async {
                     self.loadedImage = uiImage
                     self.updateNowPlayingInfo()
-                    self.updatePlayerUI()
+                    self.customViewController?.updateArtwork(image: uiImage)
                 }
             }.resume()
         }
@@ -620,6 +517,7 @@ class NowPlayingTemplate: AutoPlayTemplate {
     func onPopped() {
         config.onPopped?()
         cleanupPlayer()
+        restoreOriginalView()
 
         let commandCenter = MPRemoteCommandCenter.shared()
         commandCenter.playCommand.removeTarget(nil)
@@ -692,4 +590,8 @@ class NowPlayingTemplate: AutoPlayTemplate {
 
         updatePlayerUI()
     }
+
+    // MARK: - CPMapTemplateDelegate
+
+    func mapTemplate(_ mapTemplate: CPMapTemplate, panWith direction: CPMapTemplate.PanDirection) {}
 }

package/ios/views/NeoSkolaNowPlayingViewController.swift

@@ -0,0 +1,275 @@
+import UIKit
+
+protocol NowPlayingViewDelegate: AnyObject {
+    func didTapPlayPause()
+    func didTapPrevious()
+    func didTapNext()
+}
+
+class NeoSkolaNowPlayingViewController: UIViewController {
+    weak var delegate: NowPlayingViewDelegate?
+
+    // MARK: - UI Elements
+    private let containerView = UIView()
+    private let courseNameLabel = UILabel()
+    private let lessonNameLabel = UILabel()
+    private let artworkImageView = UIImageView()
+    private let artworkContainer = UIView()
+    private let statusLabel = UILabel()
+    private let controlsStack = UIStackView()
+    private let prevButton = UIButton(type: .system)
+    private let playPauseButton = UIButton(type: .system)
+    private let nextButton = UIButton(type: .system)
+    private let progressView = UIProgressView(progressViewStyle: .default)
+    private let currentTimeLabel = UILabel()
+    private let durationLabel = UILabel()
+    private let timeStack = UIStackView()
+
+    private var isPlaying = false
+
+    // MARK: - Lifecycle
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = UIColor(red: 0.06, green: 0.06, blue: 0.10, alpha: 1.0)
+        setupUI()
+        setupConstraints()
+    }
+
+    // MARK: - Setup
+
+    private func setupUI() {
+        containerView.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(containerView)
+
+        // Course Name (kucuk, gri)
+        courseNameLabel.font = .systemFont(ofSize: 13, weight: .medium)
+        courseNameLabel.textColor = UIColor(white: 0.55, alpha: 1.0)
+        courseNameLabel.textAlignment = .center
+        courseNameLabel.numberOfLines = 1
+        courseNameLabel.translatesAutoresizingMaskIntoConstraints = false
+        containerView.addSubview(courseNameLabel)
+
+        // Lesson Name (buyuk, beyaz, bold)
+        lessonNameLabel.font = .systemFont(ofSize: 19, weight: .bold)
+        lessonNameLabel.textColor = .white
+        lessonNameLabel.textAlignment = .center
+        lessonNameLabel.numberOfLines = 2
+        lessonNameLabel.adjustsFontSizeToFitWidth = true
+        lessonNameLabel.minimumScaleFactor = 0.7
+        lessonNameLabel.translatesAutoresizingMaskIntoConstraints = false
+        containerView.addSubview(lessonNameLabel)
+
+        // Artwork Container (golge ve yuvarlak koseler)
+        artworkContainer.translatesAutoresizingMaskIntoConstraints = false
+        artworkContainer.layer.cornerRadius = 14
+        artworkContainer.layer.shadowColor = UIColor.black.cgColor
+        artworkContainer.layer.shadowOpacity = 0.5
+        artworkContainer.layer.shadowOffset = CGSize(width: 0, height: 4)
+        artworkContainer.layer.shadowRadius = 12
+        containerView.addSubview(artworkContainer)
+
+        // Artwork Image
+        artworkImageView.contentMode = .scaleAspectFill
+        artworkImageView.clipsToBounds = true
+        artworkImageView.layer.cornerRadius = 14
+        artworkImageView.backgroundColor = UIColor(white: 0.15, alpha: 1.0)
+        artworkImageView.translatesAutoresizingMaskIntoConstraints = false
+        artworkContainer.addSubview(artworkImageView)
+
+        // Placeholder icon
+        let placeholderConfig = UIImage.SymbolConfiguration(pointSize: 32, weight: .light)
+        artworkImageView.image = UIImage(systemName: "music.note", withConfiguration: placeholderConfig)
+        artworkImageView.tintColor = UIColor(white: 0.3, alpha: 1.0)
+
+        // Status Label
+        statusLabel.font = .systemFont(ofSize: 11, weight: .semibold)
+        statusLabel.textColor = UIColor.systemGreen
+        statusLabel.textAlignment = .center
+        statusLabel.text = "OYNATILIYOR"
+        statusLabel.translatesAutoresizingMaskIntoConstraints = false
+        containerView.addSubview(statusLabel)
+
+        // Controls
+        setupControls()
+
+        // Progress Bar
+        progressView.progressTintColor = UIColor.systemGreen
+        progressView.trackTintColor = UIColor(white: 0.2, alpha: 1.0)
+        progressView.progress = 0
+        progressView.translatesAutoresizingMaskIntoConstraints = false
+        containerView.addSubview(progressView)
+
+        // Time Labels
+        currentTimeLabel.font = .monospacedDigitSystemFont(ofSize: 11, weight: .medium)
+        currentTimeLabel.textColor = UIColor(white: 0.45, alpha: 1.0)
+        currentTimeLabel.text = "0:00"
+        currentTimeLabel.translatesAutoresizingMaskIntoConstraints = false
+
+        durationLabel.font = .monospacedDigitSystemFont(ofSize: 11, weight: .medium)
+        durationLabel.textColor = UIColor(white: 0.45, alpha: 1.0)
+        durationLabel.text = "--:--"
+        durationLabel.textAlignment = .right
+        durationLabel.translatesAutoresizingMaskIntoConstraints = false
+
+        timeStack.axis = .horizontal
+        timeStack.distribution = .equalSpacing
+        timeStack.addArrangedSubview(currentTimeLabel)
+        timeStack.addArrangedSubview(durationLabel)
+        timeStack.translatesAutoresizingMaskIntoConstraints = false
+        containerView.addSubview(timeStack)
+    }
+
+    private func setupControls() {
+        // Previous Button
+        let prevConfig = UIImage.SymbolConfiguration(pointSize: 24, weight: .medium)
+        prevButton.setImage(UIImage(systemName: "backward.end.fill", withConfiguration: prevConfig), for: .normal)
+        prevButton.tintColor = .white
+        prevButton.addTarget(self, action: #selector(prevTapped), for: .touchUpInside)
+        prevButton.translatesAutoresizingMaskIntoConstraints = false
+
+        // Play/Pause Button (buyuk)
+        let playConfig = UIImage.SymbolConfiguration(pointSize: 42, weight: .medium)
+        playPauseButton.setImage(UIImage(systemName: "play.circle.fill", withConfiguration: playConfig), for: .normal)
+        playPauseButton.tintColor = UIColor.systemGreen
+        playPauseButton.addTarget(self, action: #selector(playPauseTapped), for: .touchUpInside)
+        playPauseButton.translatesAutoresizingMaskIntoConstraints = false
+
+        // Next Button
+        let nextConfig = UIImage.SymbolConfiguration(pointSize: 24, weight: .medium)
+        nextButton.setImage(UIImage(systemName: "forward.end.fill", withConfiguration: nextConfig), for: .normal)
+        nextButton.tintColor = .white
+        nextButton.addTarget(self, action: #selector(nextTapped), for: .touchUpInside)
+        nextButton.translatesAutoresizingMaskIntoConstraints = false
+
+        // Stack
+        controlsStack.axis = .horizontal
+        controlsStack.alignment = .center
+        controlsStack.distribution = .equalCentering
+        controlsStack.spacing = 40
+        controlsStack.addArrangedSubview(prevButton)
+        controlsStack.addArrangedSubview(playPauseButton)
+        controlsStack.addArrangedSubview(nextButton)
+        controlsStack.translatesAutoresizingMaskIntoConstraints = false
+        containerView.addSubview(controlsStack)
+    }
+
+    private func setupConstraints() {
+        let safeArea = view.safeAreaLayoutGuide
+
+        NSLayoutConstraint.activate([
+            // Container — tam ekran, safe area icinde
+            containerView.topAnchor.constraint(equalTo: safeArea.topAnchor, constant: 8),
+            containerView.leadingAnchor.constraint(equalTo: safeArea.leadingAnchor, constant: 20),
+            containerView.trailingAnchor.constraint(equalTo: safeArea.trailingAnchor, constant: -20),
+            containerView.bottomAnchor.constraint(equalTo: safeArea.bottomAnchor, constant: -8),
+
+            // Course Name — top
+            courseNameLabel.topAnchor.constraint(equalTo: containerView.topAnchor, constant: 4),
+            courseNameLabel.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
+            courseNameLabel.trailingAnchor.constraint(equalTo: containerView.trailingAnchor),
+
+            // Lesson Name — course name altinda
+            lessonNameLabel.topAnchor.constraint(equalTo: courseNameLabel.bottomAnchor, constant: 4),
+            lessonNameLabel.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
+            lessonNameLabel.trailingAnchor.constraint(equalTo: containerView.trailingAnchor),
+
+            // Artwork Container — merkez
+            artworkContainer.topAnchor.constraint(equalTo: lessonNameLabel.bottomAnchor, constant: 12),
+            artworkContainer.centerXAnchor.constraint(equalTo: containerView.centerXAnchor),
+            artworkContainer.widthAnchor.constraint(equalToConstant: 110),
+            artworkContainer.heightAnchor.constraint(equalToConstant: 110),
+
+            // Artwork Image — container'i doldur
+            artworkImageView.topAnchor.constraint(equalTo: artworkContainer.topAnchor),
+            artworkImageView.leadingAnchor.constraint(equalTo: artworkContainer.leadingAnchor),
+            artworkImageView.trailingAnchor.constraint(equalTo: artworkContainer.trailingAnchor),
+            artworkImageView.bottomAnchor.constraint(equalTo: artworkContainer.bottomAnchor),
+
+            // Status Label
+            statusLabel.topAnchor.constraint(equalTo: artworkContainer.bottomAnchor, constant: 10),
+            statusLabel.centerXAnchor.constraint(equalTo: containerView.centerXAnchor),
+
+            // Controls Stack — status altinda
+            controlsStack.topAnchor.constraint(equalTo: statusLabel.bottomAnchor, constant: 10),
+            controlsStack.centerXAnchor.constraint(equalTo: containerView.centerXAnchor),
+            controlsStack.widthAnchor.constraint(lessThanOrEqualTo: containerView.widthAnchor, multiplier: 0.7),
+
+            // Button min sizes
+            prevButton.widthAnchor.constraint(greaterThanOrEqualToConstant: 44),
+            prevButton.heightAnchor.constraint(greaterThanOrEqualToConstant: 44),
+            playPauseButton.widthAnchor.constraint(greaterThanOrEqualToConstant: 54),
+            playPauseButton.heightAnchor.constraint(greaterThanOrEqualToConstant: 54),
+            nextButton.widthAnchor.constraint(greaterThanOrEqualToConstant: 44),
+            nextButton.heightAnchor.constraint(greaterThanOrEqualToConstant: 44),
+
+            // Progress Bar
+            progressView.topAnchor.constraint(equalTo: controlsStack.bottomAnchor, constant: 14),
+            progressView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
+            progressView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor),
+            progressView.heightAnchor.constraint(equalToConstant: 3),
+
+            // Time Stack
+            timeStack.topAnchor.constraint(equalTo: progressView.bottomAnchor, constant: 4),
+            timeStack.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
+            timeStack.trailingAnchor.constraint(equalTo: containerView.trailingAnchor),
+        ])
+    }
+
+    // MARK: - Public Update Methods
+
+    func updateInfo(courseName: String, lessonName: String) {
+        courseNameLabel.text = courseName
+        lessonNameLabel.text = lessonName
+    }
+
+    func updatePlaybackState(isPlaying: Bool) {
+        self.isPlaying = isPlaying
+
+        let config = UIImage.SymbolConfiguration(pointSize: 42, weight: .medium)
+        let iconName = isPlaying ? "pause.circle.fill" : "play.circle.fill"
+        playPauseButton.setImage(UIImage(systemName: iconName, withConfiguration: config), for: .normal)
+        playPauseButton.tintColor = isPlaying ? UIColor.systemOrange : UIColor.systemGreen
+
+        statusLabel.text = isPlaying ? "OYNATILIYOR" : "DURAKLATILDI"
+        statusLabel.textColor = isPlaying ? UIColor.systemGreen : UIColor.systemGray
+    }
+
+    func updateTime(elapsed: Double, duration: Double) {
+        currentTimeLabel.text = formatTime(elapsed)
+        durationLabel.text = duration > 0 ? formatTime(duration) : "--:--"
+
+        if duration > 0 {
+            let progress = Float(min(elapsed / duration, 1.0))
+            progressView.setProgress(progress, animated: true)
+        }
+    }
+
+    func updateArtwork(image: UIImage) {
+        artworkImageView.image = image
+        artworkImageView.contentMode = .scaleAspectFill
+    }
+
+    // MARK: - Helpers
+
+    private func formatTime(_ seconds: Double) -> String {
+        guard !seconds.isNaN && !seconds.isInfinite && seconds >= 0 else { return "0:00" }
+        let mins = Int(seconds) / 60
+        let secs = Int(seconds) % 60
+        return String(format: "%d:%02d", mins, secs)
+    }
+
+    // MARK: - Actions
+
+    @objc private func prevTapped() {
+        delegate?.didTapPrevious()
+    }
+
+    @objc private func playPauseTapped() {
+        delegate?.didTapPlayPause()
+    }
+
+    @objc private func nextTapped() {
+        delegate?.didTapNext()
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neoskola/auto-play",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",