基于Android Media Framework管理音乐队列及MediaSessionCompat可行性咨询

Great question! Let’s break this down because managing media queues—especially for offline players—can feel like mixing two separate jobs: keeping your app’s internal state consistent, and syncing that state with the system’s media controls. Here’s the straight scoop:

Core Queue Logic: You Need to Implement This Yourself #

MediaSessionCompat isn’t designed to be your primary queue storage. It’s a bridge between your app and system-level media UI (like the notification bar, lock screen, or car play controls). So you’ll need to maintain your own source of truth for the queue—usually a mutable list or a dedicated data structure.

For offline playback, this is even more critical because all your media content is local:

• Use something like ArrayList<MediaSessionCompat.QueueItem> to store your queue. Each QueueItem should use a unique mediaId tied to your local media (e.g., a database ID, file path hash, or unique identifier for the offline track).
• Handle adding, deleting, and reordering directly on this list. This ensures your app’s internal state is always the single source of truth, even if the MediaSession gets reset (like when your app restarts).

Example Code Snippets #

Adding a Song to the Queue

// Your app's internal queue storage
private val offlineMediaQueue = mutableListOf<MediaSessionCompat.QueueItem>()

fun addOfflineSongToQueue(localSong: LocalTrack) {
    // Build a QueueItem with a unique mediaId and queue ID
    val queueItem = MediaSessionCompat.QueueItem(
        MediaDescriptionCompat.Builder()
            .setMediaId(localSong.uniqueId)
            .setTitle(localSong.title)
            .setSubtitle(localSong.artist)
            .setIconUri(Uri.fromFile(localSong.coverArtFile)) // Local cover art
            .build(),
        localSong.uniqueId.hashCode().toLong() // Unique queue item ID
    )
    
    // Update your internal queue first
    offlineMediaQueue.add(queueItem)
    // Then sync to MediaSession
    mediaSession.setQueue(offlineMediaQueue)
}

Deleting a Song from the Queue

fun removeSongFromQueue(queueItemId: Long) {
    // Remove from your internal list
    offlineMediaQueue.removeAll { it.queueId == queueItemId }
    // Sync the updated queue to MediaSession
    mediaSession.setQueue(offlineMediaQueue)
}

Reordering the Queue (e.g., Drag-and-Drop)

fun reorderQueue(fromPos: Int, toPos: Int) {
    if (fromPos in offlineMediaQueue.indices && toPos in offlineMediaQueue.indices) {
        val movedItem = offlineMediaQueue.removeAt(fromPos)
        offlineMediaQueue.add(toPos, movedItem)
        // Sync the reordered list to MediaSession
        mediaSession.setQueue(offlineMediaQueue)
    }
}

MediaSessionCompat: Use It to Sync with System Controls #

While you handle the core queue logic, MediaSessionCompat’s methods like addQueueItem() or setQueue() are for syncing your internal state to the system. Here’s how to use them effectively:

• After modifying your internal queue, always call mediaSession.setQueue(yourInternalQueue) to update what the system’s media UI displays.
• When users interact with system controls (e.g., swiping to delete a song from the notification bar), MediaSessionCompat.Callback methods like onRemoveQueueItem() or onAddQueueItem() will trigger. You must update your internal queue in these callbacks to keep everything in sync.

Example Callback Handling #

val mediaSessionCallback = object : MediaSessionCompat.Callback() {
    override fun onAddQueueItem(description: MediaDescriptionCompat?) {
        description?.mediaId?.let { mediaId ->
            // Fetch the local track using the mediaId, then add to your internal queue
            val localTrack = localMediaRepository.getTrackByMediaId(mediaId)
            localTrack?.let { addOfflineSongToQueue(it) }
        }
    }

    override fun onRemoveQueueItem(description: MediaDescriptionCompat?) {
        description?.mediaId?.let { mediaId ->
            offlineMediaQueue.removeAll { it.description.mediaId == mediaId }
            mediaSession.setQueue(offlineMediaQueue)
        }
    }
}

// Attach the callback to your MediaSession
mediaSession.setCallback(mediaSessionCallback)

Offline-Specific Tips #

• Persist your queue: Save the list of mediaIds from your queue to SharedPreferences or a local database. When your app restarts, rebuild the QueueItem list from these persisted IDs to restore the user’s queue.
• Validate local media: Before adding a QueueItem, double-check that the local file exists (since it’s offline—files might be deleted by the user outside your app).

内容的提问来源于stack exchange，提问作者Akash Bisariya