capacitor-plugin-playlist 0.9.4 → 0.10.3

package/CapacitorPluginPlaylist.podspec

@@ -10,7 +10,7 @@ Pod::Spec.new do |s|
   s.homepage = package['repository']['url']
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
-  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
   s.ios.deployment_target = '18.0'
   s.dependency 'Capacitor'
   s.swift_version = '5.3'

package/Package.swift

@@ -0,0 +1,31 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "CapacitorPluginPlaylist",
+    platforms: [.iOS(.v18)],
+    products: [
+        .library(
+            name: "CapacitorPluginPlaylist",
+            targets: ["PlaylistPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
+    ],
+    targets: [
+        .target(
+            name: "PlaylistPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/PlaylistPlugin",
+            swiftSettings: [
+                .swiftLanguageMode(.v5),
+            ]),
+        .testTarget(
+            name: "PlaylistPluginTests",
+            dependencies: ["PlaylistPlugin"],
+            path: "ios/Tests/PlaylistPluginTests")
+    ]
+)

package/android/src/main/java/org/dwbn/plugins/playlist/PlaylistPlugin.kt

@@ -7,6 +7,8 @@ import com.devbrackets.android.playlistcore.data.MediaProgress
 import com.getcapacitor.*
 import com.getcapacitor.annotation.CapacitorPlugin
 import org.dwbn.plugins.playlist.data.AudioTrack
+import org.dwbn.plugins.playlist.playlist.AudioPlaylistHandler
+import org.dwbn.plugins.playlist.service.MediaService
 import org.json.JSONArray
 import org.json.JSONObject
 import java.util.*
@@ -214,20 +216,18 @@ public class PlaylistPlugin : Plugin(), OnStatusReportListener {
     fun play(call: PluginCall) {
         Handler(Looper.getMainLooper()).post {
             val handler = audioPlayerImpl!!.playlistManager.playlistHandler
+            val serviceForeground = MediaService.instance?.isRunningInForeground() == true
             if (handler == null || handler.currentMediaPlayer == null) {
-                // MediaPlayer was released or MediaService was killed (e.g. after a long video session
-                // where audio focus was permanently abandoned). Fall back to beginPlayback which
-                // re-starts the service, re-prepares the MediaPlayer, and re-acquires audio focus.
                 val posMs = (audioPlayerImpl!!.getLastKnownPositionSec() * 1000f).toLong()
-                audioPlayerImpl!!.playlistManager.beginPlayback(posMs, false)
-                Log.i(TAG, "play: handler/mediaPlayer was null — re-armed via beginPlayback at ${posMs}ms")
-            } else {
-                // Handler and MediaPlayer are alive — use the lightweight resume path.
-                // Guard against stacking up repeat cycles (playlistcore bug): skip if already playing.
-                val isPlaying = handler.currentMediaPlayer?.isPlaying ?: false
-                if (!isPlaying) {
-                    handler.play()
+                if (serviceForeground && handler is AudioPlaylistHandler<*, *>) {
+                    handler.startItemPlayback(posMs, false)
+                    Log.i(TAG, "play: re-armed via startItemPlayback at ${posMs}ms (FGS already foreground)")
+                } else {
+                    audioPlayerImpl!!.playlistManager.beginPlayback(posMs, false)
+                    Log.i(TAG, "play: handler/mediaPlayer was null — re-armed via beginPlayback at ${posMs}ms")
                 }
+            } else {
+                handler.play()
             }
 
             call.resolve()
@@ -257,11 +257,14 @@ public class PlaylistPlugin : Plugin(), OnStatusReportListener {
         Handler(Looper.getMainLooper()).post {
             val id: String = call.getString("id")!!
             if ("" != id) {
-                // alternatively we could search for the item and set the current index to that item.
                 val code = id.hashCode()
                 val seekPosition = (call.getFloat("position", 0f)!! * 1000.0f).toLong()
                 audioPlayerImpl!!.playlistManager.setCurrentItem(code.toLong())
-                audioPlayerImpl!!.playlistManager.beginPlayback(seekPosition, false)
+                val handler = audioPlayerImpl!!.playlistManager.playlistHandler
+                val alreadyPlaying = handler?.currentMediaPlayer?.isPlaying == true
+                if (!audioPlayerImpl!!.tryResumeVideoHandoffInPlace(seekPosition) && !alreadyPlaying) {
+                    audioPlayerImpl!!.playlistManager.beginPlayback(seekPosition, false)
+                }
             }
 
             call.resolve()
@@ -406,9 +409,10 @@ public class PlaylistPlugin : Plugin(), OnStatusReportListener {
     fun resumeAfterVideoHandoff(call: PluginCall) {
         Handler(Looper.getMainLooper()).post {
             val position = call.getFloat("position", 0f)!!
-            audioPlayerImpl!!.resumeAfterVideoHandoff(position)
+            val prewarm = call.getBoolean("prewarm", false) ?: false
+            audioPlayerImpl!!.resumeAfterVideoHandoff(position, prewarm)
             call.resolve()
-            Log.i(TAG, "resumeAfterVideoHandoff")
+            Log.i(TAG, "resumeAfterVideoHandoff prewarm=$prewarm")
         }
     }
 

package/android/src/main/java/org/dwbn/plugins/playlist/RmxAudioPlayer.java

@@ -20,6 +20,8 @@ import org.dwbn.plugins.playlist.data.AudioTrack;
 import org.dwbn.plugins.playlist.manager.MediaControlsListener;
 import org.dwbn.plugins.playlist.manager.Options;
 import org.dwbn.plugins.playlist.manager.PlaylistManager;
+import org.dwbn.plugins.playlist.playlist.AudioPlaylistHandler;
+import org.dwbn.plugins.playlist.service.MediaService;
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -460,25 +462,63 @@ public class RmxAudioPlayer implements PlaybackStatusListener<AudioTrack>,
         } else {
             lastKnownHandoffPositionSec = 0f;
         }
-        // Pause unconditionally (not only when isPlaying) so that DefaultAudioFocusProvider
-        // always abandons audio focus before CapacitorVideoPlayer.initPlayer acquires it.
-        // Calling pause() on an already-paused handler is safe; it triggers focus release.
-        if (playlistManager.getPlaylistHandler() != null) {
-            playlistManager.getPlaylistHandler().pause(false);
+        com.devbrackets.android.playlistcore.components.playlisthandler.PlaylistHandler<?> handler =
+                playlistManager.getPlaylistHandler();
+        if (handler instanceof AudioPlaylistHandler) {
+            ((AudioPlaylistHandler<?, ?>) handler).pauseForVideoHandoff();
+        } else if (handler != null) {
+            handler.pause(false);
         }
     }
 
     public void resumeAfterVideoHandoff(float positionSec) {
+        resumeAfterVideoHandoff(positionSec, false);
+    }
+
+    public void resumeAfterVideoHandoff(float positionSec, boolean prewarm) {
         lastKnownHandoffPositionSec = positionSec;
-        // Re-arm the audio session/service so the handler is primed before JS calls play().
-        // On Android, prepareForVideoHandoff() abandoned audio focus which may have caused
-        // the MediaService to stop itself (foreground service removal). beginPlayback with
-        // startPaused=true restarts the service, re-acquires audio focus, and prepares the
-        // MediaPlayer at the stored position — without auto-starting playback (JS owns FR111).
         long positionMs = (long) (positionSec * 1000f);
+        if (prewarm) {
+            playlistManager.setVideoHandoffForegroundRetain(true);
+            playlistManager.beginPlayback(positionMs, true);
+            return;
+        }
+        if (tryResumeVideoHandoffInPlace(positionMs)) {
+            return;
+        }
+        // Service not foreground — last resort (may be muted on Android 17 when backgrounded).
+        playlistManager.setVideoHandoffForegroundRetain(false);
         playlistManager.beginPlayback(positionMs, true);
     }
 
+    /**
+     * Resume audio at {@code positionMs} without restarting MediaService (Android 17 AudioHardening).
+     */
+    public boolean tryResumeVideoHandoffInPlace(long positionMs) {
+        if (!playlistManager.getVideoHandoffForegroundRetain()) {
+            return false;
+        }
+        MediaService service = MediaService.getInstance();
+        if (service == null || !service.isRunningInForeground()) {
+            return false;
+        }
+        com.devbrackets.android.playlistcore.components.playlisthandler.PlaylistHandler<?> handler =
+                playlistManager.getPlaylistHandler();
+        if (!(handler instanceof AudioPlaylistHandler)) {
+            return false;
+        }
+        AudioPlaylistHandler<?, ?> audioHandler = (AudioPlaylistHandler<?, ?>) handler;
+        com.devbrackets.android.playlistcore.api.MediaPlayerApi<?> mediaPlayer = audioHandler.getCurrentMediaPlayer();
+        if (mediaPlayer != null) {
+            audioHandler.resumePlaybackAfterVideoHandoff(positionMs);
+        } else {
+            // Re-prepare within the existing foreground service — do not call beginPlayback/startService.
+            audioHandler.startItemPlayback(positionMs, false);
+        }
+        playlistManager.setVideoHandoffForegroundRetain(false);
+        return true;
+    }
+
     public float getLastKnownPositionSec() {
         return lastKnownHandoffPositionSec;
     }

package/android/src/main/java/org/dwbn/plugins/playlist/manager/PlaylistManager.kt

@@ -29,6 +29,10 @@ class PlaylistManager(application: Application) :
     var isShouldStopPlaylist = false
     var currentErrorTrack: AudioTrack? = null
 
+    /** When true, MediaService stays in foreground during native video (Android 17 AudioHardening). */
+    var videoHandoffForegroundRetain = false
+    var mediaServiceInForeground = false
+
     // Really need a way to propagate the settings through the app
     var resetStreamOnPause = true
     var options: Options

package/android/src/main/java/org/dwbn/plugins/playlist/playlist/AudioPlaylistHandler.java

@@ -16,12 +16,14 @@ import com.devbrackets.android.playlistcore.components.mediacontrols.MediaContro
 import com.devbrackets.android.playlistcore.components.mediasession.DefaultMediaSessionProvider;
 import com.devbrackets.android.playlistcore.components.mediasession.MediaSessionProvider;
 import com.devbrackets.android.playlistcore.components.playlisthandler.DefaultPlaylistHandler;
+import com.devbrackets.android.playlistcore.data.PlaybackState;
 import com.devbrackets.android.playlistcore.manager.BasePlaylistManager;
 
 import org.dwbn.plugins.playlist.RmxAudioPlayer;
 import org.dwbn.plugins.playlist.data.AudioTrack;
 import org.dwbn.plugins.playlist.manager.PlaylistManager;
 import org.dwbn.plugins.playlist.notification.PlaylistNotificationProvider;
+import org.dwbn.plugins.playlist.service.MediaService;
 import org.jetbrains.annotations.NotNull;
 
 
@@ -65,11 +67,126 @@ public class AudioPlaylistHandler<I extends PlaylistItem, M extends BasePlaylist
         startItemPlayback(0, !this.isPlaying());
     }
 
+    /**
+     * Request audio focus before starting ExoMedia — DefaultPlaylistHandler.play() starts the
+     * MediaPlayer first, which fails silently after native video handoff (focus abandoned in
+     * pauseForVideoHandoff while the video ExoPlayer still held the stream).
+     * During Epic 45 prewarm (native video active), never request focus or start audible playback.
+     */
+    @Override
+    public void play() {
+        if (isVideoHandoffPrewarmActive()) {
+            setupForeground();
+            return;
+        }
+        getAudioFocusProvider().requestFocus();
+        com.devbrackets.android.playlistcore.api.MediaPlayerApi<I> mediaPlayer = getCurrentMediaPlayer();
+        if (mediaPlayer != null) {
+            if (mediaPlayer.isPlaying()) {
+                mediaPlayer.pause();
+            }
+            mediaPlayer.play();
+        }
+        getMediaProgressPoll().start();
+        setPlaybackState(PlaybackState.PLAYING);
+        setupForeground();
+    }
+
+    /**
+     * Resume at {@code positionMs} after native video ends. Re-requests focus and clears a stale
+     * isPlaying() state before {@link #play()}.
+     */
+    public void resumePlaybackAfterVideoHandoff(long positionMs) {
+        ((PlaylistManager) getPlaylistManager()).setVideoHandoffForegroundRetain(false);
+        getAudioFocusProvider().requestFocus();
+        com.devbrackets.android.playlistcore.api.MediaPlayerApi<I> mediaPlayer = getCurrentMediaPlayer();
+        if (mediaPlayer != null) {
+            if (positionMs > 0) {
+                seek(positionMs);
+            }
+            if (mediaPlayer.isPlaying()) {
+                mediaPlayer.pause();
+            }
+        }
+        play();
+    }
+
+    /**
+     * Release audio focus for video without tearing down the foreground service (Epic 45 / Android 17).
+     */
+    public void pauseForVideoHandoff() {
+        if (isPlaying()) {
+            com.devbrackets.android.playlistcore.api.MediaPlayerApi<I> mediaPlayer = getCurrentMediaPlayer();
+            if (mediaPlayer != null) {
+                mediaPlayer.pause();
+            }
+        }
+        getMediaProgressPoll().stop();
+        setPlaybackState(com.devbrackets.android.playlistcore.data.PlaybackState.PAUSED);
+        getAudioFocusProvider().abandonFocus();
+    }
+
+    @Override
+    public void pause(boolean isTemporary) {
+        if (((PlaylistManager) getPlaylistManager()).getVideoHandoffForegroundRetain()) {
+            if (isPlaying()) {
+                com.devbrackets.android.playlistcore.api.MediaPlayerApi<I> mediaPlayer = getCurrentMediaPlayer();
+                if (mediaPlayer != null) {
+                    mediaPlayer.pause();
+                }
+            }
+            getMediaProgressPoll().stop();
+            setPlaybackState(com.devbrackets.android.playlistcore.data.PlaybackState.PAUSED);
+            if (!isTemporary) {
+                getAudioFocusProvider().abandonFocus();
+            }
+            return;
+        }
+        super.pause(isTemporary);
+    }
+
+    @Override
+    protected void relaxResources() {
+        if (((PlaylistManager) getPlaylistManager()).getVideoHandoffForegroundRetain()) {
+            return;
+        }
+        super.relaxResources();
+    }
+
+    /**
+     * Android 17 AudioHardening: re-calling startForeground from background revokes WIU and mutes playback.
+     * When prewarm already promoted MediaService, only update the notification via super when not foreground.
+     */
+    @Override
+    protected void setupForeground() {
+        MediaService service = MediaService.getInstance();
+        if (service != null && service.isRunningInForeground()) {
+            return;
+        }
+        super.setupForeground();
+    }
+
     @Override
     public void onPrepared(@NotNull MediaPlayerApi<I> mediaPlayer) {
+        if (isVideoHandoffPrewarmActive()) {
+            // Prewarm: prepare at seek position but stay silent — native video owns audio focus.
+            super.onPrepared(mediaPlayer);
+            com.devbrackets.android.playlistcore.api.MediaPlayerApi<I> currentPlayer = getCurrentMediaPlayer();
+            if (currentPlayer != null && currentPlayer.isPlaying()) {
+                currentPlayer.pause();
+            }
+            getMediaProgressPoll().stop();
+            setPlaybackState(com.devbrackets.android.playlistcore.data.PlaybackState.PAUSED);
+            getAudioFocusProvider().abandonFocus();
+            return;
+        }
         super.onPrepared(mediaPlayer);
     }
 
+    private boolean isVideoHandoffPrewarmActive() {
+        return ((PlaylistManager) getPlaylistManager()).getVideoHandoffForegroundRetain();
+    }
+
     @Override
     public boolean onError(@NotNull MediaPlayerApi<I> mediaPlayer) {
         ((PlaylistManager)getPlaylistManager()).setCurrentErrorTrack((AudioTrack) getCurrentPlaylistItem());

package/android/src/main/java/org/dwbn/plugins/playlist/service/MediaService.kt

@@ -22,9 +22,14 @@ import org.dwbn.plugins.playlist.service.MediaImageProvider.OnImageUpdatedListen
 class MediaService : BasePlaylistService<AudioTrack, PlaylistManager>() {
     companion object {
         private const val TAG = "MediaService"
+
+        @JvmStatic
+        @Volatile
+        var instance: MediaService? = null
     }
 
     override fun onCreate() {
+        instance = this
         super.onCreate()
         // Adds the audio player implementation, otherwise there's nothing to play media with
         val newAudio = AudioApi(applicationContext)
@@ -33,6 +38,7 @@ class MediaService : BasePlaylistService<AudioTrack, PlaylistManager>() {
     }
 
     override fun onDestroy() {
+        instance = null
         super.onDestroy()
 
         // Releases and clears all the MediaPlayersMediaImageProvider
@@ -57,6 +63,7 @@ class MediaService : BasePlaylistService<AudioTrack, PlaylistManager>() {
 
     override fun runAsForeground(notificationId: Int, notification: Notification) {
         if (inForeground) {
+            playlistManager.mediaServiceInForeground = true
             return
         }
 
@@ -68,15 +75,27 @@ class MediaService : BasePlaylistService<AudioTrack, PlaylistManager>() {
                 startForeground(notificationId, notification,
                     ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
             }
+            playlistManager.mediaServiceInForeground = true
         } catch (e: android.app.ForegroundServiceStartNotAllowedException) {
             // Android 12+ blocks foreground service start from background
             // Log the error but don't crash - service can still function without foreground status
             Log.w(TAG, "Cannot start foreground service: app is in background", e)
             inForeground = false
+            playlistManager.mediaServiceInForeground = false
             // Service will continue as a regular service (may be killed by system)
         }
     }
 
+    override fun endForeground(removeNotification: Boolean) {
+        if (playlistManager.videoHandoffForegroundRetain) {
+            return
+        }
+        super.endForeground(removeNotification)
+        playlistManager.mediaServiceInForeground = false
+    }
+
+    fun isRunningInForeground(): Boolean = inForeground
+
     override val playlistManager: PlaylistManager
         get() = (applicationContext as App).playlistManager
 

package/dist/docs.json

@@ -1916,6 +1916,13 @@
           "docs": "",
           "complexTypes": [],
           "type": "number"
+        },
+        {
+          "name": "prewarm",
+          "tags": [],
+          "docs": "Android: keep MediaService FGS alive (with WIU) while native video plays.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },

package/dist/esm/RmxAudioPlayer.d.ts

@@ -15,7 +15,7 @@ export declare class RmxAudioPlayer {
      * because they properly interpret the range of these values, but this field is exposed if you wish to observe
      * or interrogate it.
      */
-    get currentState(): "error" | "stopped" | "unknown" | "paused" | "loading" | "playing" | "ready";
+    get currentState(): "unknown" | "ready" | "error" | "playing" | "loading" | "paused" | "stopped";
     get currentTrack(): AudioTrack | null;
     /**
      * If the playlist is currently playling a track.

package/dist/esm/definitions.d.ts

@@ -43,6 +43,8 @@ export interface PlaylistPlugin {
 }
 export interface ResumeAfterVideoHandoffOptions {
     position: number;
+    /** Android: keep MediaService FGS alive (with WIU) while native video plays. */
+    prewarm?: boolean;
 }
 export interface GetLastKnownPositionResult {
     position: number;

package/ios/{Plugin → Sources/PlaylistPlugin}/DispatchQueue.swift

@@ -1,8 +1,8 @@
 import Dispatch
 
-private var throttleWorkItems = [AnyHashable: DispatchWorkItem]()
-private var lastDebounceCallTimes = [AnyHashable: DispatchTime]()
-private let nilContext: AnyHashable = arc4random()
+nonisolated(unsafe) private var throttleWorkItems = [AnyHashable: DispatchWorkItem]()
+nonisolated(unsafe) private var lastDebounceCallTimes = [AnyHashable: DispatchTime]()
+nonisolated(unsafe) private let nilContext: AnyHashable = arc4random()
 
 public extension DispatchQueue {
     /**

package/ios/{Plugin → Sources/PlaylistPlugin}/Plugin.swift

@@ -9,7 +9,36 @@ protocol StatusUpdater {
  * here: https://capacitorjs.com/docs/plugins/ios
  */
 @objc(PlaylistPlugin)
-public class PlaylistPlugin: CAPPlugin, StatusUpdater {
+public class PlaylistPlugin: CAPPlugin, StatusUpdater, CAPBridgedPlugin {
+    public let identifier = "PlaylistPlugin"
+    public let jsName = "Playlist"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "setOptions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "initialize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "release", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setPlaylistItems", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "addItem", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "addAllItems", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeItem", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeItems", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "clearAllItems", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPlaylist", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "play", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "pause", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "skipForward", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "skipBack", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "seekTo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "playTrackByIndex", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "playTrackById", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "selectTrackByIndex", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "selectTrackById", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setPlaybackVolume", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setLoop", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setPlaybackRate", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "prepareForVideoHandoff", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "resumeAfterVideoHandoff", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getLastKnownPosition", returnType: CAPPluginReturnPromise),
+    ]
     let audioPlayerImpl = RmxAudioPlayer()
     
     // MARK: - Capacitor API
@@ -185,7 +214,8 @@ public class PlaylistPlugin: CAPPlugin, StatusUpdater {
 
     @objc func resumeAfterVideoHandoff(_ call: CAPPluginCall) {
         let position = call.getFloat("position", 0)
-        audioPlayerImpl.resumeAfterVideoHandoff(position: position)
+        let prewarm = call.getBool("prewarm", false)
+        audioPlayerImpl.resumeAfterVideoHandoff(position: position, prewarm: prewarm)
         call.resolve()
     }
 

package/ios/{Plugin → Sources/PlaylistPlugin}/RmxAudioPlayer.swift

@@ -1235,8 +1235,11 @@ final class RmxAudioPlayer: NSObject {
         }
     }
 
-    func resumeAfterVideoHandoff(position: Float) {
+    func resumeAfterVideoHandoff(position: Float, prewarm: Bool = false) {
         lastKnownHandoffPosition = position
+        if prewarm {
+            return
+        }
         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`

package/ios/{PluginTests → Tests/PlaylistPluginTests}/PluginTests.swift

@@ -1,5 +1,5 @@
 import XCTest
-@testable import Plugin
+@testable import PlaylistPlugin
 
 class PluginTests: XCTestCase {
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-playlist",
-  "version": "0.9.4",
+  "version": "0.10.3",
   "description": "Playlist ",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -9,12 +9,13 @@
   "files": [
     "dist/",
     "ios/",
+    "Package.swift",
     "android/",
     "CapacitorPluginPlaylist.podspec"
   ],
   "scripts": {
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
-    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin && cd ..",
+    "verify:ios": "xcodebuild -scheme CapacitorPluginPlaylist -destination generic/platform=iOS",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "npm run build",
     "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
@@ -26,8 +27,7 @@
     "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
     "clean": "rimraf ./dist",
     "watch": "tsc --watch",
-    "prepublishOnly": "npm run build",
-    "prepare": "npm run build"
+    "prepublishOnly": "npm run build"
   },
   "author": "phiamo",
   "license": "MIT",

package/ios/Plugin/Info.plist

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>$(DEVELOPMENT_LANGUAGE)</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>FMWK</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleVersion</key>
-	<string>$(CURRENT_PROJECT_VERSION)</string>
-	<key>NSPrincipalClass</key>
-	<string></string>
-</dict>
-</plist>

package/ios/Plugin/Plugin.h

@@ -1,10 +0,0 @@
-#import <UIKit/UIKit.h>
-
-//! Project version number for Plugin.
-FOUNDATION_EXPORT double PluginVersionNumber;
-
-//! Project version string for Plugin.
-FOUNDATION_EXPORT const unsigned char PluginVersionString[];
-
-// In this header, you should import all the public headers of your framework using statements like #import <Plugin/PublicHeader.h>
-

package/ios/Plugin/Plugin.m

@@ -1,29 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <Capacitor/Capacitor.h>
-
-// Define the plugin using the CAP_PLUGIN Macro, and
-// each method the plugin supports using the CAP_PLUGIN_METHOD macro.
-CAP_PLUGIN(PlaylistPlugin, "Playlist",
-   CAP_PLUGIN_METHOD(setOptions, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(initialize, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(release, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(setPlaylistItems, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(addItem, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(addAllItems, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(removeItem, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(removeItems, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(clearAllItems, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(getPlaylist, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(play, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(pause, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(skipForward, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(skipBack, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(seekTo, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(playTrackByIndex, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(playTrackById, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(selectTrackByIndex, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(selectTrackById, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(setPlaybackVolume, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(setLoop, CAPPluginReturnPromise);
-   CAP_PLUGIN_METHOD(setPlaybackRate, CAPPluginReturnPromise);
-)