capacitor-plugin-playlist 0.10.3 → 0.10.9

package/ios/Sources/PlaylistPlugin/RmxAudioPlayer.swift

@@ -52,6 +52,7 @@ final class RmxAudioPlayer: NSObject {
     private var resetStreamOnPause = false
     private var updatedNowPlayingInfo: [String : Any]?
     private let nowPlayingInfoQueue = DispatchQueue(label: "RMXAudioPlayerNowPlayingQueue")
+    private let coverArtworkCache = NSCache<NSURL, MPMediaItemArtwork>()
     private var isReplacingItems = false
     private var isWaitingToStartPlayback = false
     private var loop = false
@@ -161,16 +162,17 @@ final class RmxAudioPlayer: NSObject {
         var removed = 0
         if items.count > 0 {
             for item in items {
-                guard let item = item as? [String: String] else {
+                guard let item = item as? [String: Any] else {
                     continue
                 }
-                if let id = item["trackId"] {
+
+                if let id = item["id"] as? String {
                     do {
                         try removeItem(id)
                         removed += 1
                     } catch {}
                 }
-                else if let index = Int(item["trackIndex"]!) {
+                else if let index = (item["index"] as? NSNumber)?.intValue {
                     do {
                         try removeItem(index)
                         removed += 1
@@ -305,22 +307,9 @@ final class RmxAudioPlayer: NSObject {
         // Re-arm the periodic observer if it was removed by a prior releaseResources() call.
         installPlaybackTimeObserverIfNeeded()
         
-        // Ensure audio session is active before playing
-        // This is critical when resuming after video player has deactivated the session
-        let audioSession = AVAudioSession.sharedInstance()
-        if !audioSession.isOtherAudioPlaying {
-            // Only reactivate if no other audio is playing
-            do {
-                try audioSession.setActive(true)
-            } catch {
-                print("Warning: Could not activate audio session: \(error.localizedDescription)")
-                // Try to reactivate with category setup
-                activateAudioSession()
-            }
-        } else {
-            // If other audio is playing, ensure our category is set correctly
-            activateAudioSession()
-        }
+        // Always re-activate after native video handoff — `isOtherAudioPlaying` can still be true
+        // briefly while AVPlayerViewController tears down, which previously skipped setActive.
+        activateAudioSession()
 
         if resetStreamOnPause,
            let currentTrack = avQueuePlayer.currentAudioTrack,
@@ -714,9 +703,7 @@ final class RmxAudioPlayer: NSObject {
                 updatedNowPlayingInfo![MPMediaItemPropertyTitle] = currentItem?.title
                 updatedNowPlayingInfo![MPMediaItemPropertyAlbumTitle] = currentItem?.album
 
-                if let mediaItemArtwork = createCoverArtwork(currentItem?.albumArt?.absoluteString) {
-                    updatedNowPlayingInfo![MPMediaItemPropertyArtwork] = mediaItemArtwork
-                }
+                updateNowPlayingArtwork(currentItem?.albumArt?.absoluteString)
             }
             updatedNowPlayingInfo![MPMediaItemPropertyPlaybackDuration] = duration ?? 0.0
             updatedNowPlayingInfo![MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentTime ?? 0.0
@@ -730,52 +717,76 @@ final class RmxAudioPlayer: NSObject {
         commandCenter.previousTrackCommand.isEnabled = !avQueuePlayer.isAtBeginning
     }
 
-    func createCoverArtwork(_ coverUriOrNil: String?) -> MPMediaItemArtwork? {
+    private func updateNowPlayingArtwork(_ coverUriOrNil: String?) {
         guard let coverUri = coverUriOrNil else {
-            return nil
+            updatedNowPlayingInfo?.removeValue(forKey: MPMediaItemPropertyArtwork)
+            return
         }
-        var coverImage: UIImage? = nil
-        if coverUri.hasPrefix("http://") || coverUri.hasPrefix("https://") {
-            let coverImageUrl = URL(string: coverUri)!
 
-            do {
-                let coverImageData = try Data(contentsOf: coverImageUrl)
-                coverImage = UIImage(data: coverImageData)
-            } catch {
-                print("Error creating the coverImageData");
+        if coverUri.hasPrefix("http://") || coverUri.hasPrefix("https://") {
+            guard let coverImageUrl = URL(string: coverUri) else {
+                updatedNowPlayingInfo?.removeValue(forKey: MPMediaItemPropertyArtwork)
+                return
             }
-        } else {
-            if FileManager.default.fileExists(atPath: coverUri) {
-                coverImage = UIImage(contentsOfFile: coverUri)
+
+            if let cachedArtwork = coverArtworkCache.object(forKey: coverImageUrl as NSURL) {
+                updatedNowPlayingInfo?[MPMediaItemPropertyArtwork] = cachedArtwork
+                return
             }
+
+            updatedNowPlayingInfo?.removeValue(forKey: MPMediaItemPropertyArtwork)
+
+            URLSession.shared.dataTask(with: coverImageUrl) { [weak self] data, response, error in
+                guard
+                    error == nil,
+                    let httpResponse = response as? HTTPURLResponse,
+                    (200..<300).contains(httpResponse.statusCode),
+                    let self = self,
+                    let data = data,
+                    let coverImage = UIImage(data: data),
+                    self.isCoverImageValid(coverImage)
+                else {
+                    return
+                }
+
+                DispatchQueue.main.async {
+                    let artwork = MPMediaItemArtwork(boundsSize: coverImage.size) { _ in coverImage }
+                    self.coverArtworkCache.setObject(artwork, forKey: coverImageUrl as NSURL)
+
+                    guard self.avQueuePlayer.currentAudioTrack?.albumArt?.absoluteString == coverUri else {
+                        return
+                    }
+
+                    self.nowPlayingInfoQueue.sync {
+                        self.updatedNowPlayingInfo?[MPMediaItemPropertyArtwork] = artwork
+                        MPNowPlayingInfoCenter.default().nowPlayingInfo = self.updatedNowPlayingInfo
+                    }
+                }
+            }.resume()
+            return
         }
 
-        if isCoverImageValid(coverImage) {
-            return MPMediaItemArtwork.init(boundsSize: coverImage!.size, requestHandler: { (size) -> UIImage in
-                return coverImage!
-            })
+        if let mediaItemArtwork = createCoverArtwork(coverUri) {
+            updatedNowPlayingInfo?[MPMediaItemPropertyArtwork] = mediaItemArtwork
+        } else {
+            updatedNowPlayingInfo?.removeValue(forKey: MPMediaItemPropertyArtwork)
         }
-        return nil;
     }
 
-    func downloadImage(url: URL, completion: @escaping ((_ image: UIImage?) -> Void)){
-        print("Started downloading \"\(url.deletingPathExtension().lastPathComponent)\".")
-        self.getImageDataFromUrl(url) { (_ data: Data?) in
-            DispatchQueue.main.async {
-                print("Finished downloading \"\(url.deletingPathExtension().lastPathComponent)\".")
-                completion(UIImage(data: data!))
-            }
+    private func createCoverArtwork(_ coverUri: String) -> MPMediaItemArtwork? {
+        guard
+            FileManager.default.fileExists(atPath: coverUri),
+            let coverImage = UIImage(contentsOfFile: coverUri),
+            isCoverImageValid(coverImage)
+        else {
+            return nil
         }
-    }
 
-    func getImageDataFromUrl(_ url: URL, completion: @escaping ((_ data: Data?) -> Void)) {
-        URLSession.shared.dataTask(with: url) { (data, response, error) in
-            completion(data)
-        }.resume()
+        return MPMediaItemArtwork(boundsSize: coverImage.size) { _ in coverImage }
     }
 
-    func isCoverImageValid(_ coverImage: UIImage?) -> Bool {
-        return coverImage != nil && (coverImage?.ciImage != nil || coverImage?.cgImage != nil)
+    private func isCoverImageValid(_ coverImage: UIImage) -> Bool {
+        return coverImage.ciImage != nil || coverImage.cgImage != nil
     }
 
     func handleCurrentItemChanged(_ playerItem: AudioTrack?) {
@@ -1218,6 +1229,8 @@ final class RmxAudioPlayer: NSObject {
     // MARK: - Epic 45 video handoff
 
     private var lastKnownHandoffPosition: Float = 0
+    /// Track id at video open — AVQueuePlayer can advance while video owns the session.
+    private var handoffPinnedTrackId: String?
 
     func prepareForVideoHandoff() {
         pauseCommand(false)
@@ -1225,9 +1238,14 @@ final class RmxAudioPlayer: NSObject {
         // true stopped head, not a value that may have ticked during the pause call.
         if let track = avQueuePlayer.currentAudioTrack {
             lastKnownHandoffPosition = getTrackCurrentTime(track)
+            handoffPinnedTrackId = track.trackId
         } else {
             lastKnownHandoffPosition = 0
+            handoffPinnedTrackId = nil
         }
+        // Freeze queue: HLS item failure while paused still triggers .advance otherwise.
+        avQueuePlayer.actionAtItemEnd = .none
+        print("prepareForVideoHandoff: pinned=\(handoffPinnedTrackId ?? "nil") actionAtItemEnd=none")
         do {
             try AVAudioSession.sharedInstance().setActive(false, options: [.notifyOthersOnDeactivation])
         } catch {
@@ -1235,17 +1253,61 @@ final class RmxAudioPlayer: NSObject {
         }
     }
 
-    func resumeAfterVideoHandoff(position: Float, prewarm: Bool = false) {
+    /// Completes with `true` when native handled seek (and play when requested) so JS can skip redundant seek/play.
+    func resumeAfterVideoHandoff(
+        position: Float,
+        prewarm: Bool = false,
+        play: Bool = false,
+        completion: @escaping (Bool) -> Void
+    ) {
         lastKnownHandoffPosition = position
         if prewarm {
+            completion(false)
             return
         }
+        avQueuePlayer.actionAtItemEnd = .advance
+        let currentId = avQueuePlayer.currentAudioTrack?.trackId
+        if let pinned = handoffPinnedTrackId, !pinned.isEmpty, currentId != pinned {
+            print("resumeAfterVideoHandoff: restoring pinned=\(pinned) (was \(currentId ?? "nil"))")
+            do {
+                try selectTrack(id: pinned)
+            } catch {
+                print("resumeAfterVideoHandoff: selectTrack failed: \(error.localizedDescription)")
+            }
+        } else {
+            print("resumeAfterVideoHandoff: pinned=\(handoffPinnedTrackId ?? "nil") current=\(currentId ?? "nil")")
+        }
+        handoffPinnedTrackId = nil
+        // Always re-arm session after native video (AVPlayer teardown can briefly look like other audio).
         activateAudioSession()
         // Reset lastTrackId so the timeControlStatus KVO guard does not suppress the PLAYING
         // event on same-track non-index-0 resume. The guard `lastTrackId != trackId || isAtBeginning`
         // (where isAtBeginning = currentIndex() == 0) would silently drop the PLAYING transition
         // for any audio track at playlist index > 0, leaving JS stuck in PAUSED.
         lastTrackId = nil
+
+        let finish: () -> Void = { [weak self] in
+            guard let self = self else {
+                completion(true)
+                return
+            }
+            if play {
+                self.playCommand(false)
+                NSLog("[Playlist] resumeAfterVideoHandoff: seek-then-play at %.3f", position)
+            } else {
+                NSLog("[Playlist] resumeAfterVideoHandoff: seek-only at %.3f", position)
+            }
+            completion(true)
+        }
+
+        if position > 0 {
+            let seekToTime = CMTimeMakeWithSeconds(Float64(position), preferredTimescale: 1000)
+            avQueuePlayer.seek(to: seekToTime, toleranceBefore: .zero, toleranceAfter: .zero) { _ in
+                finish()
+            }
+        } else {
+            finish()
+        }
     }
 
     func getLastKnownPosition() -> Float {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-playlist",
-  "version": "0.10.3",
+  "version": "0.10.9",
   "description": "Playlist ",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",