capacitor-plugin-playlist 0.11.2 → 0.13.0

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

@@ -0,0 +1,98 @@
+package org.dwbn.plugins.playlist.manager
+
+import androidx.media3.common.Player
+
+/**
+ * Playback decisions that keep the Media3 playlist behaving like the former PlaylistCore stack.
+ * Pure functions so JVM tests pin the parity rules.
+ */
+object PlaylistPlaybackPolicy {
+    /** PlaylistCore skipped a failing item up to this many times in a row before giving up. */
+    const val MAX_SEQUENTIAL_ERRORS = 3
+
+    /**
+     * PlaylistCore never repeated a single item: with one item `next` was unavailable even when
+     * looping, so playback stopped at its end. Media3 `REPEAT_MODE_ALL` would restart it forever.
+     */
+    @JvmStatic
+    fun repeatMode(loop: Boolean, itemCount: Int): Int =
+        if (loop && itemCount > 1) Player.REPEAT_MODE_ALL else Player.REPEAT_MODE_OFF
+
+    @JvmStatic
+    fun nextAvailable(index: Int, itemCount: Int, loop: Boolean): Boolean {
+        if (itemCount <= 1) {
+            return false
+        }
+        val isAtEnd = index + 1 >= itemCount
+        return if (isAtEnd) loop else index + 1 in 0 until itemCount
+    }
+
+    /**
+     * Window index for [Player.seekTo] after a failed item, matching [PlaylistManager.skipFailedItem]:
+     * next item, or wrap to 0 at the end of the list.
+     */
+    @JvmStatic
+    fun errorSkipWindowIndex(failedIndex: Int, itemCount: Int): Int {
+        if (itemCount <= 0) {
+            return 0
+        }
+        return if (failedIndex + 1 >= itemCount) 0 else failedIndex + 1
+    }
+
+    @JvmStatic
+    fun previousAvailable(index: Int, loop: Boolean, itemCount: Int): Boolean {
+        if (itemCount <= 0) {
+            return false
+        }
+        return index > 0 || loop
+    }
+
+    /**
+     * Window index for [Player.seekTo] when skipping forward, matching [PlaylistManager.skipToNext]:
+     * next item, or wrap to 0 at the end of the list when looping.
+     */
+    @JvmStatic
+    fun nextSkipIndex(fromIndex: Int, itemCount: Int, loop: Boolean): Int =
+        if (fromIndex + 1 >= itemCount && loop) 0 else fromIndex + 1
+
+    /**
+     * Window index for [Player.seekTo] when skipping backward, matching
+     * [PlaylistManager.skipToPrevious]: previous item, or wrap to the last item when looping.
+     */
+    @JvmStatic
+    fun previousSkipIndex(fromIndex: Int, itemCount: Int, loop: Boolean): Int =
+        if (fromIndex <= 0 && loop) itemCount - 1 else fromIndex - 1
+
+    /** An item played to its end and the player moved on by itself (not a seek or list change). */
+    @JvmStatic
+    fun isNaturalItemEnd(transitionReason: Int): Boolean =
+        transitionReason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
+            transitionReason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT
+
+    @JvmStatic
+    fun shouldSkipAfterError(sequentialErrors: Int, nextAvailable: Boolean): Boolean =
+        nextAvailable && sequentialErrors <= MAX_SEQUENTIAL_ERRORS
+
+    /**
+     * PlaylistCore assumed the user had pressed play for every item after the first, so it kept
+     * playing after skipping a broken item unless the failure hit the auto-buffered first item.
+     */
+    @JvmStatic
+    fun playWhenReadyAfterErrorSkip(playWhenReady: Boolean, failedIndex: Int): Boolean =
+        playWhenReady || failedIndex > 0
+
+    /** Media3 ignores play on an idle or ended player; it must be prepared or rewound first. */
+    @JvmStatic
+    fun needsPrepareBeforePlay(playbackState: Int): Boolean = playbackState == Player.STATE_IDLE
+
+    @JvmStatic
+    fun needsRewindBeforePlay(playbackState: Int): Boolean = playbackState == Player.STATE_ENDED
+
+    /**
+     * `resetStreamOnPause`: resume a paused live stream at the live edge instead of where it paused.
+     * VOD streams (`isStream` HLS lectures) are not live and keep their position.
+     */
+    @JvmStatic
+    fun shouldJumpToLiveEdge(resetStreamOnPause: Boolean, isStream: Boolean, isLive: Boolean): Boolean =
+        resetStreamOnPause && isStream && isLive
+}

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

@@ -0,0 +1,11 @@
+package org.dwbn.plugins.playlist.manager
+
+enum class RmxPlaybackState {
+    STOPPED,
+    RETRIEVING,
+    PREPARING,
+    SEEKING,
+    PLAYING,
+    PAUSED,
+    ERROR
+}

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

@@ -1,262 +1,158 @@
 package org.dwbn.plugins.playlist.playlist;
 
-import android.app.Service;
 import android.content.Context;
-import android.util.Log;
-
 import androidx.annotation.Nullable;
-
-import com.devbrackets.android.playlistcore.api.MediaPlayerApi;
-import com.devbrackets.android.playlistcore.api.PlaylistItem;
-import com.devbrackets.android.playlistcore.components.audiofocus.AudioFocusProvider;
-import com.devbrackets.android.playlistcore.components.audiofocus.DefaultAudioFocusProvider;
-import com.devbrackets.android.playlistcore.components.image.ImageProvider;
-import com.devbrackets.android.playlistcore.components.mediacontrols.DefaultMediaControlsProvider;
-import com.devbrackets.android.playlistcore.components.mediacontrols.MediaControlsProvider;
-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 androidx.annotation.OptIn;
+import androidx.media3.common.Player;
+import androidx.media3.common.util.UnstableApi;
 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;
-
-
-public class AudioPlaylistHandler<I extends PlaylistItem, M extends BasePlaylistManager<I>>
-            extends DefaultPlaylistHandler<I, M> {
+import org.dwbn.plugins.playlist.manager.PlaylistPlaybackPolicy;
+import org.dwbn.plugins.playlist.handoff.VideoPlayerBridge;
+import org.dwbn.plugins.playlist.service.MediaNotificationPolicy;
+
+/**
+ * ExoPlayer playback facade for {@link org.dwbn.plugins.playlist.PlaylistPlugin}. Story 55.4
+ * replaces PlaylistCore's {@code DefaultPlaylistHandler}; notification/focus polish is Story 55.5,
+ * full video handoff behaviour is Story 55.6.
+ */
+@OptIn(markerClass = UnstableApi.class)
+public class AudioPlaylistHandler {
+
+    private final Context context;
+    private final PlaylistManager playlistManager;
+
+    public AudioPlaylistHandler(Context context, PlaylistManager playlistManager) {
+        this.context = context.getApplicationContext();
+        this.playlistManager = playlistManager;
+    }
 
-    private static final String TAG = "PlaylistAudioPlaylistHandler";
+    public boolean isPlaying() {
+        return playlistManager.isPlaying();
+    }
 
-    AudioPlaylistHandler(
-            Context context,
-            Class<? extends Service> serviceClass,
-            M playlistManager,
-            ImageProvider<I> imageProvider,
-            com.devbrackets.android.playlistcore.components.notification.PlaylistNotificationProvider notificationProvider,
-            MediaSessionProvider mediaSessionProvider,
-            MediaControlsProvider mediaControlsProvider,
-            AudioFocusProvider<I> audioFocusProvider,
-            @Nullable Listener<I> listener
-    ) {
-        super(context, serviceClass, playlistManager, imageProvider, notificationProvider,
-                mediaSessionProvider, mediaControlsProvider, audioFocusProvider, listener);
-        // Lmao this entire class exists for the sake of this one line
-        // The default value is 30fps (e.g 33ms), which would overwhelm the Cordova webview with messages
-        // Ideally we could make this configurable.
-        getMediaProgressPoll().setProgressPollDelay(1000);
+    @Nullable
+    public Player getCurrentMediaPlayer() {
+        return playlistManager.getPlayer();
     }
 
-    public void next() {
-        if (!getPlaylistManager().isNextAvailable()) {
+    public void play() {
+        if (MediaNotificationPolicy.shouldIgnoreSessionPlay(
+            playlistManager.isVideoHandoffPrewarmActive(),
+            VideoPlayerBridge.hasActivePlayer()
+        )) {
+            playlistManager.ensureForeground();
             return;
         }
-        getPlaylistManager().next();
-        startItemPlayback(0, !this.isPlaying());
+        playlistManager.ensureServiceStarted();
+        playlistManager.ensureForeground();
+        if (MediaNotificationPolicy.shouldRequestLegacyAudioFocus()) {
+            // Media3 handleAudioFocus owns pause/resume; do not call AudioManager.requestAudioFocus.
+        }
+        Player player = playlistManager.getPlayer();
+        AudioTrack track = playlistManager.getCurrentItem();
+        jumpToLiveEdgeIfReset(player, playlistManager.getResetStreamOnPause(), track != null && track.isStream());
+        startAudible(player);
     }
 
-    public void previous() {
-        if (!getPlaylistManager().isPreviousAvailable()) {
-            return;
+    /** Visible for JVM tests — `resetStreamOnPause` resumes live streams at the live edge. */
+    static void jumpToLiveEdgeIfReset(@Nullable Player player, boolean resetStreamOnPause, boolean isStream) {
+        if (player != null
+            && PlaylistPlaybackPolicy.shouldJumpToLiveEdge(resetStreamOnPause, isStream, player.isCurrentMediaItemLive())) {
+            player.seekToDefaultPosition();
         }
-        getPlaylistManager().previous();
-        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();
+    /** Visible for JVM tests — PlaylistCore's play restarted an idle or finished player. */
+    static void startAudible(@Nullable Player player) {
+        if (player == null) {
             return;
         }
-        getAudioFocusProvider().requestFocus();
-        com.devbrackets.android.playlistcore.api.MediaPlayerApi<I> mediaPlayer = getCurrentMediaPlayer();
-        if (mediaPlayer != null) {
-            if (mediaPlayer.isPlaying()) {
-                mediaPlayer.pause();
-            }
-            mediaPlayer.play();
+        int state = player.getPlaybackState();
+        if (PlaylistPlaybackPolicy.needsRewindBeforePlay(state)) {
+            player.seekToDefaultPosition(player.getCurrentMediaItemIndex());
+        }
+        if (PlaylistPlaybackPolicy.needsPrepareBeforePlay(state)) {
+            player.prepare();
         }
-        getMediaProgressPoll().start();
-        setPlaybackState(PlaybackState.PLAYING);
-        setupForeground();
+        player.setPlayWhenReady(true);
     }
 
-    /**
-     * 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);
+    public void pause(boolean isTemporary) {
+        Player player = playlistManager.getPlayer();
+        if (player != null) {
+            player.setPlayWhenReady(false);
         }
     }
 
-    /**
-     * 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();
-            }
+    public void seek(long positionMs) {
+        Player player = playlistManager.getPlayer();
+        if (player != null) {
+            player.seekTo(positionMs);
         }
-        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();
-            }
+    public void startItemPlayback(long positionMs, boolean startPaused) {
+        playlistManager.ensureServiceStarted();
+        playlistManager.beginPlaybackAt(positionMs, startPaused);
+    }
+
+    public void next() {
+        if (!playlistManager.isNextAvailable()) {
             return;
         }
-        super.pause(isTemporary);
+        playlistManager.skipToNext();
     }
 
-    @Override
-    protected void relaxResources() {
-        if (((PlaylistManager) getPlaylistManager()).getVideoHandoffForegroundRetain()) {
+    public void previous() {
+        if (!playlistManager.isPreviousAvailable()) {
             return;
         }
-        super.relaxResources();
+        playlistManager.skipToPrevious();
     }
 
     /**
-     * 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.
+     * Resume at {@code positionMs} after native video ends. Media3 {@code handleAudioFocus} owns
+     * focus. Clears retain before audible play, then play-then-seek (seek-while-paused stays silent).
      */
-    @Override
-    protected void setupForeground() {
-        MediaService service = MediaService.getInstance();
-        if (service != null && service.isRunningInForeground()) {
-            return;
-        }
-        super.setupForeground();
+    public void resumePlaybackAfterVideoHandoff(long positionMs) {
+        playlistManager.setVideoHandoffForegroundRetain(false);
+        playlistManager.ensureServiceStarted();
+        playlistManager.ensureForeground();
+        applyAudibleResume(playlistManager.getPlayer(), positionMs);
     }
 
-    @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();
+    /** Visible for JVM tests — play then seek so audio is not left paused after video. */
+    static void applyAudibleResume(@Nullable Player player, long positionMs) {
+        if (player == null) {
             return;
         }
-        super.onPrepared(mediaPlayer);
-    }
-
-    private boolean isVideoHandoffPrewarmActive() {
-        return ((PlaylistManager) getPlaylistManager()).getVideoHandoffForegroundRetain();
-    }
-
-    @Override
-    public boolean onError(@NotNull MediaPlayerApi<I> mediaPlayer) {
-        ((PlaylistManager)getPlaylistManager()).setCurrentErrorTrack((AudioTrack) getCurrentPlaylistItem());
-        int currentIndex = getPlaylistManager().getCurrentPosition();
-        int currentErrorCount = getSequentialErrors();
-
-        super.onError(mediaPlayer);
-        // Do not set startPaused to false if we are at the first item.
-        // For all other items, the user MUST have triggered playback;
-        // for item 0, they will never have done so at this point (since the tracks
-        // are auto-buffered when a list is loaded).
-        // This is a bit of a guess. What happens of tracks 2,3,4 are also broken?
-        // User has no network? The only way to be *certain* is to capture all user interaction
-        // input points and create a global flag "somewhere" that says the user has tried to play.
-        // Maintaining that would be a nightmare.
-        if (currentIndex > 0 && currentErrorCount <= 3) {
-            Log.e(TAG, "ListHandler error: setting startPaused to false");
-            setStartPaused(false);
+        if (MediaNotificationPolicy.shouldPlayThenSeekOnResume()) {
+            player.setPlayWhenReady(true);
+            if (positionMs > 0) {
+                player.seekTo(positionMs);
+            }
+        } else {
+            if (positionMs > 0) {
+                player.seekTo(positionMs);
+            }
+            player.setPlayWhenReady(true);
         }
-
-        return false;
-    }
-
-    @Override
-    public void onSeekComplete(MediaPlayerApi<I> mediaPlayer) {
-        Log.i(TAG, "onSeekComplete! " + mediaPlayer.getCurrentPosition());
-        getCurrentMediaProgress().update(mediaPlayer.getCurrentPosition(), mediaPlayer.getBufferedPercent(), mediaPlayer.getDuration());
-        super.onSeekComplete(mediaPlayer);
     }
 
-    @Override
-    public void onCompletion(@NotNull MediaPlayerApi<I> mediaPlayer) {
-        ((RmxAudioPlayer)super.getPlaylistManager().getPlaybackStatusListener()).onCompletion((AudioTrack) getCurrentPlaylistItem());
-        Log.i("AudioPlaylistHandler", "onCompletion");
-        // This is called when a single item completes playback.
-        // For now, the superclass does the right thing, but we may need to override.
-        super.onCompletion(mediaPlayer);
+    /** Pause for video without tearing down the foreground service (Epic 45 / Story 55.6). */
+    public void pauseForVideoHandoff() {
+        pauseForVideoHandoff(playlistManager.getPlayer());
     }
 
-
-    public static class Builder<I extends PlaylistItem, M extends BasePlaylistManager<I>> {
-
-        Context context;
-        Class<? extends Service> serviceClass;
-        M playlistManager;
-        ImageProvider<I> imageProvider;
-
-        com.devbrackets.android.playlistcore.components.notification.PlaylistNotificationProvider notificationProvider = null;
-        MediaSessionProvider mediaSessionProvider = null;
-        MediaControlsProvider mediaControlsProvider = null;
-        AudioFocusProvider<I> audioFocusProvider = null;
-        Listener<I> listener;
-        public Builder(Context context, Class<? extends Service> serviceClass,
-                       M playlistManager, ImageProvider<I> imageProvider, Listener<I> listener) {
-            this.context = context;
-            this.serviceClass = serviceClass;
-            this.playlistManager = playlistManager;
-            this.imageProvider = imageProvider;
-            this.listener = listener;
+    /** Visible for JVM tests — pauses even when {@code isPlaying} is false. */
+    static void pauseForVideoHandoff(@Nullable Player player) {
+        if (player != null && MediaNotificationPolicy.shouldPauseForVideoHandoff(player.isPlaying())) {
+            player.setPlayWhenReady(false);
         }
+    }
 
-        public AudioPlaylistHandler<I, M> build() {
-            return new AudioPlaylistHandler<>(context,
-                serviceClass,
-                playlistManager,
-                imageProvider,
-                notificationProvider != null ? notificationProvider : new PlaylistNotificationProvider(context),
-                mediaSessionProvider != null ? mediaSessionProvider : new DefaultMediaSessionProvider(context, serviceClass),
-                mediaControlsProvider != null ? mediaControlsProvider : new DefaultMediaControlsProvider(context),
-                audioFocusProvider != null ? audioFocusProvider : new DefaultAudioFocusProvider<I>(context),
-                listener);
-        }
+    public void updateMediaControls() {
+        playlistManager.updateForegroundNotification();
     }
 }

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

@@ -0,0 +1,121 @@
+package org.dwbn.plugins.playlist.service
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.util.BitmapLoader
+import androidx.media3.common.util.UnstableApi
+import com.bumptech.glide.Glide
+import com.bumptech.glide.request.target.CustomTarget
+import com.bumptech.glide.request.transition.Transition
+import com.google.common.util.concurrent.ListenableFuture
+import com.google.common.util.concurrent.SettableFuture
+
+/**
+ * Glide-backed [BitmapLoader] for Media3 notification / lock-screen artwork.
+ * Load failures complete the future exceptionally so Media3 keeps the small icon only.
+ */
+@OptIn(UnstableApi::class)
+class GlideBitmapLoader(context: Context) : BitmapLoader {
+    private val appContext = context.applicationContext
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    override fun supportsMimeType(mimeType: String): Boolean {
+        return isSupportedImageMimeType(mimeType)
+    }
+
+    override fun decodeBitmap(data: ByteArray): ListenableFuture<Bitmap> {
+        val future = SettableFuture.create<Bitmap>()
+        try {
+            val bitmap = BitmapFactory.decodeByteArray(data, 0, data.size)
+            if (bitmap == null) {
+                future.setException(IllegalStateException("Failed to decode artwork bytes"))
+            } else {
+                future.set(bitmap)
+            }
+        } catch (t: Throwable) {
+            if (!future.isDone) {
+                future.setException(t)
+            }
+        }
+        return future
+    }
+
+    override fun loadBitmap(uri: Uri): ListenableFuture<Bitmap> {
+        return loadWithGlide(uri)
+    }
+
+    override fun loadBitmapFromMetadata(metadata: MediaMetadata): ListenableFuture<Bitmap>? {
+        if (MediaNotificationPolicy.hasNoLargeArtwork(metadata.artworkData, metadata.artworkUri?.toString())) {
+            return null
+        }
+        val data = metadata.artworkData
+        if (data != null && data.isNotEmpty()) {
+            return decodeBitmap(data)
+        }
+        val uri = metadata.artworkUri
+        if (uri != null && MediaNotificationPolicy.shouldLoadRemoteArtwork(uri.toString())) {
+            return loadBitmap(uri)
+        }
+        return null
+    }
+
+    private fun loadWithGlide(model: Any): ListenableFuture<Bitmap> {
+        val future = SettableFuture.create<Bitmap>()
+        val load = Runnable {
+            try {
+                Glide.with(appContext)
+                    .asBitmap()
+                    .load(model)
+                    .into(object : CustomTarget<Bitmap>() {
+                        override fun onResourceReady(
+                            resource: Bitmap,
+                            transition: Transition<in Bitmap>?
+                        ) {
+                            future.set(resource)
+                        }
+
+                        override fun onLoadFailed(errorDrawable: Drawable?) {
+                            if (!future.isDone) {
+                                future.setException(IllegalStateException("Artwork load failed"))
+                            }
+                        }
+
+                        override fun onLoadCleared(placeholder: Drawable?) {
+                            if (!future.isDone) {
+                                future.setException(IllegalStateException("Artwork load cleared"))
+                            }
+                        }
+                    })
+            } catch (t: Throwable) {
+                if (!future.isDone) {
+                    future.setException(t)
+                }
+            }
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            load.run()
+        } else if (!mainHandler.post(load)) {
+            future.setException(IllegalStateException("Artwork load post failed"))
+        }
+        return future
+    }
+
+    companion object {
+        @JvmStatic
+        fun isSupportedImageMimeType(mimeType: String?): Boolean {
+            return !mimeType.isNullOrEmpty() && mimeType.startsWith("image/", ignoreCase = true)
+        }
+
+        @JvmStatic
+        fun shouldLoadRemoteArtwork(artworkUri: String?): Boolean {
+            return MediaNotificationPolicy.shouldLoadRemoteArtwork(artworkUri)
+        }
+    }
+}