capacitor-plugin-playlist 0.9.5 → 0.10.8

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,14 @@ public class PlaylistPlugin : Plugin(), OnStatusReportListener {
     fun resumeAfterVideoHandoff(call: PluginCall) {
         Handler(Looper.getMainLooper()).post {
             val position = call.getFloat("position", 0f)!!
-            audioPlayerImpl!!.resumeAfterVideoHandoff(position)
-            call.resolve()
-            Log.i(TAG, "resumeAfterVideoHandoff")
+            val prewarm = call.getBoolean("prewarm", false) ?: false
+            // Default true preserves legacy Android in-place play when `play` is omitted.
+            val play = call.getBoolean("play", true) ?: true
+            val resumed = audioPlayerImpl!!.resumeAfterVideoHandoff(position, prewarm, play)
+            val result = JSObject()
+            result.put("resumed", resumed)
+            call.resolve(result)
+            Log.i(TAG, "resumeAfterVideoHandoff prewarm=$prewarm play=$play resumed=$resumed")
         }
     }
 

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,23 +462,76 @@ 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) {
+    public boolean resumeAfterVideoHandoff(float positionSec) {
+        return resumeAfterVideoHandoff(positionSec, false, true);
+    }
+
+    /**
+     * @return {@code true} when in-place resume already seeked and started playback
+     *         (JS should skip redundant seekTo/play); {@code false} for prewarm, paused handoff,
+     *         or last-resort beginPlayback.
+     */
+    public boolean resumeAfterVideoHandoff(float positionSec, boolean prewarm) {
+        return resumeAfterVideoHandoff(positionSec, prewarm, true);
+    }
+
+    public boolean resumeAfterVideoHandoff(float positionSec, boolean prewarm, boolean play) {
         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 false;
+        }
+        if (!play) {
+            // Paused video exit — do not start audio; JS will seekTo only.
+            playlistManager.setVideoHandoffForegroundRetain(false);
+            return false;
+        }
+        if (tryResumeVideoHandoffInPlace(positionMs)) {
+            return true;
+        }
+        // Service not foreground — last resort (may be muted on Android 17 when backgrounded).
+        playlistManager.setVideoHandoffForegroundRetain(false);
         playlistManager.beginPlayback(positionMs, true);
+        return false;
+    }
+
+    /**
+     * 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() {

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,125 @@ 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 starts playback.
+     * <p>
+     * Must {@link #play()} before {@link #seek(long)}: playlistcore {@code performSeek} sets
+     * {@code playingBeforeSeek = isPlaying()}. After video handoff the player is paused, so
+     * seek-then-play races with {@code onSeekComplete}, which calls {@code pause()} when
+     * {@code playingBeforeSeek} is false — UI briefly shows playing while native audio stays silent.
+     */
+    public void resumePlaybackAfterVideoHandoff(long positionMs) {
+        ((PlaylistManager) getPlaylistManager()).setVideoHandoffForegroundRetain(false);
+        setStartPaused(false);
+        getAudioFocusProvider().requestFocus();
+        play();
+        if (positionMs > 0) {
+            seek(positionMs);
+        }
+    }
+
+    /**
+     * 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