如何使用 Android MediaSessionCompat 获取通知回调答案

【问题标题】：How to get notification callbacks using Android MediaSessionCompat如何使用 Android MediaSessionCompat 获取通知回调
【发布时间】：2018-09-09 15:18:16
【问题描述】：

我在使用 Android 的 MediaSession 时遇到了一些困难。

我一直在开发一个原型收音机应用程序，它应该从一个 url 流式传输。

到目前为止，我已经将它与前台服务一起使用，该服务可以通过主屏幕中的按钮进行控制。音频按预期继续超出应用程序的宽度，但是我有一个通知，根据播放状态显示播放或停止按钮。

我的问题是这个按钮不起作用。

我检测到onStartCommand 正在被媒体按钮意图调用，但调用MediaButtonReceiver.handleIntent(mediaSession, intent) 却没有任何反应。我注册的MediaCallback 永远不会被调用。

我已经阅读了这方面的文档，观看了 Google 的 youtube 系列，将其与一些演示应用程序进行了比较，并浏览了 StackOverflow，但到目前为止，我找不到任何适用于我的应用程序的解决方案。

我可以将媒体回调按钮换成通知上的自定义按钮，但我不想这样做，我更愿意让它与 MediaSession 一起工作，这样我就可以集成手表、自动和锁定屏幕。

这是我所拥有的服务：

import android.app.*
import android.content.Context
import android.content.Intent
import android.os.IBinder
import android.support.v4.app.NotificationManagerCompat
import android.support.v4.content.ContextCompat
import project.base.App
import project.dagger.FeatureDagger
import javax.inject.Inject
import android.graphics.BitmapFactory
import android.support.v4.media.MediaMetadataCompat
import android.support.v4.media.session.MediaSessionCompat
import android.media.AudioManager
import android.os.Build
import android.support.v4.media.session.MediaButtonReceiver
import android.support.v4.media.session.PlaybackStateCompat
import android.util.Log
import project.dagger.holder.FeatureHolder
import project.extensions.toActivityPendingIntent
import project.story.listen.*

private const val NOTIFICATION_ID = 1

class PlaybackService : Service(), PlaybackInteraction, ListenView {

    @Inject lateinit var interactor: PlaybackInteractor
    @Inject lateinit var presenter: ListenPresenter
    @Inject lateinit var notificationFactory: NotificationFactory

    private lateinit var mediaSession: MediaSessionCompat

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onCreate() {
        super.onCreate()

        FeatureDagger.create(application as App).component.inject(this)
        FeatureHolder.create(application as App)

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) notificationFactory.createChannel()

        mediaSession = MediaSessionCompat(this, "PlayerService")
        mediaSession.setFlags(
                        MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS or
                        MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS)
        mediaSession.setCallback(MediaCallback(
                presenter::playTapped,
                presenter::stopTapped,
                presenter::terminatePlayback))
        mediaSession.setSessionActivity(launchIntent())
        mediaSession.setMetadata(metadata())


        val audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager
        audioManager.requestAudioFocus({
            // Ignore
        }, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)

        mediaSession.isActive = true

        presenter.onViewCreated(this)
        presenter.onStart()
        interactor.onInteractionCreated(this)
    }

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        MediaButtonReceiver.handleIntent(mediaSession, intent)
        return START_NOT_STICKY
    }

    override fun showState(state: State) =
            when (state) {
                State.BUFFERING -> buffering()
                State.PLAYING -> playing()
                State.STOPPED -> stopped()
            }

    private fun buffering() =
            startForeground(NOTIFICATION_ID, notificationFactory.bufferingNotification())

    private fun playing() {
        mediaSession.setPlaybackState(playingState())
        startForeground(NOTIFICATION_ID, notificationFactory.playingNotification(mediaSession))
    }

    private fun stopped() {
        mediaSession.setPlaybackState(stoppedState())
        stopForeground(false)
        NotificationManagerCompat
                .from(this)
                .notify(NOTIFICATION_ID, notificationFactory.stoppedNotification(mediaSession))
    }

    override fun dismiss() {
        mediaSession.release()

        stopSelf()
    }

    private fun playingState() =
            PlaybackStateCompat.Builder()
                    .setState(PlaybackStateCompat.STATE_PLAYING, 0, 0f)
                    .setActions(PlaybackStateCompat.ACTION_STOP)
                    .build()

    private fun stoppedState() =
            PlaybackStateCompat.Builder()
                    .setState(PlaybackStateCompat.STATE_STOPPED, 0, 0f)
                    .setActions(PlaybackStateCompat.ACTION_PLAY_PAUSE)
                    .build()

    private fun metadata() =
            MediaMetadataCompat.Builder()
                    .putString(MediaMetadataCompat.METADATA_KEY_ARTIST, "Test Artist")
                    .putString(MediaMetadataCompat.METADATA_KEY_ALBUM, "Test Album")
                    .putString(MediaMetadataCompat.METADATA_KEY_TITLE, "Test Track Name")
                    .putLong(MediaMetadataCompat.METADATA_KEY_DURATION, 10000)
                    .putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART,
                            BitmapFactory.decodeResource(resources,
                                    R.mipmap.ic_launcher))
                    .build()

    private fun launchIntent() =
            ListenActivity.buildIntent(this)
                    .toActivityPendingIntent(this)

    companion object {
        fun launch(context: Context) =
                ContextCompat.startForegroundService(context, Intent(context, PlaybackService::class.java))
    }
}

这是它的清单部分：

<service android:name="project.story.playback.PlaybackService">
            <intent-filter>
                <action android:name="android.intent.action.MEDIA_BUTTON" />
            </intent-filter>
        </service>

        <receiver android:name="android.support.v4.media.session.MediaButtonReceiver">
            <intent-filter>
                <action android:name="android.intent.action.MEDIA_BUTTON"/>
            </intent-filter>
        </receiver>

我的最低版本是 23，所以我实际上不需要包含一些代码，但我已经测试过，它似乎没有任何区别。

MediaCallback 被设计为可重复使用，它的来源：

import android.support.v4.media.session.MediaSessionCompat

class MediaCallback(
        private val onPlay: () -> Unit,
        private val onPause: () -> Unit,
        private val onStop: () -> Unit)
    : MediaSessionCompat.Callback() {

    override fun onPlay() {
        super.onPlay()

        onPlay.invoke()
    }

    override fun onPause() {
        super.onPause()

        onPause.invoke()
    }

    override fun onStop() {
        super.onStop()

        onStop.invoke()
    }
}

NotificationFactory的来源如下：

import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build
import android.support.annotation.RequiresApi
import android.support.v4.app.NotificationCompat
import android.support.v4.content.ContextCompat
import android.support.v4.media.session.MediaButtonReceiver
import android.support.v4.media.session.MediaSessionCompat
import android.support.v4.media.session.PlaybackStateCompat
import project.extensions.toActivityPendingIntent
import project.feature.listen.R
import project.story.listen.ListenActivity

private const val CHANNEL_ID = "playback"

class NotificationFactory(private val context: Context) {

    private fun baseNotification() =
            NotificationCompat
                    .Builder(context, CHANNEL_ID)
                    .setContentTitle(context.getString(R.string.app_name))
                    .setSmallIcon(uk.co.keithkirk.cuillinfm.R.drawable.ic_notification)
                    .setColor(ContextCompat.getColor(context, uk.co.keithkirk.cuillinfm.R.color.accent))
                    .setAutoCancel(false)
                    .setContentIntent(launchIntent())
                    .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)

    fun bufferingNotification() =
            baseNotification()
                    .setOngoing(true)
                    .setContentText(context.getString(R.string.buffering))
                    .setProgress(0, 0, true)
                    .build()

    fun playingNotification(session: MediaSessionCompat) =
            baseNotification()
                    .setOngoing(true)
                    .setContentText(context.getString(R.string.playing))
                    .setStyle(android.support.v4.media.app.NotificationCompat.MediaStyle()
                            .setMediaSession(session.sessionToken)
                            .setShowCancelButton(true)
                            .setCancelButtonIntent(
                                    MediaButtonReceiver.buildMediaButtonPendingIntent(
                                            context,
                                            PlaybackStateCompat.ACTION_STOP)))
                    .addAction(stopAction())
                    .build()

    fun stoppedNotification(session: MediaSessionCompat) =
            baseNotification()
                    .setOngoing(false)
                    .setContentText(context.getString(R.string.stopped))
                    .setDeleteIntent(terminateIntent())
                    .setStyle(android.support.v4.media.app.NotificationCompat.MediaStyle()
                            .setMediaSession(session.sessionToken)
                            .setShowCancelButton(false))
                    .addAction(playAction())
                    .build()

    @RequiresApi(Build.VERSION_CODES.O)
    fun createChannel() {
        val channel = NotificationChannel(CHANNEL_ID,
                context.getString(R.string.media_playback),
                NotificationManager.IMPORTANCE_LOW)

        channel.description = context.getString(R.string.media_playback_controls)
        channel.setShowBadge(false)
        channel.lockscreenVisibility = Notification.VISIBILITY_PUBLIC

        (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
                .createNotificationChannel(channel)
    }

    private fun launchIntent() =
            ListenActivity.buildIntent(context)
                    .toActivityPendingIntent(context)

    private fun playAction() = NotificationCompat.Action(
            R.drawable.ic_play_arrow_white,
            context.getString(R.string.play),
            playIntent())

    private fun stopAction() = NotificationCompat.Action(
            R.drawable.ic_stop_white,
            context.getString(R.string.stop),
            stopIntent())

    private fun playIntent() =
            MediaButtonReceiver.buildMediaButtonPendingIntent(
                context,
                PlaybackStateCompat.ACTION_PLAY)

    private fun stopIntent() =
            MediaButtonReceiver.buildMediaButtonPendingIntent(
                context,
                PlaybackStateCompat.ACTION_PAUSE)

    private fun terminateIntent() =
            MediaButtonReceiver.buildMediaButtonPendingIntent(
                context,
                PlaybackStateCompat.ACTION_STOP)
}

PlaybackInteractor 和ListenPresenter 是架构的表示层，因此它们通过事件总线与更广泛的系统进行通信。我将对其进行总结，但除非有必要，否则我会避免发布源代码，因为这篇文章已经足够大了。

ListenPresenter 在点击/需要播放、停止或终止时被告知，它在事件总线上发布这些指令，它还从总线读取当前播放状态并通知视图进行更新（在这种情况下，服务更新通知）。此演示者的另一个实例已连接到主屏幕上的按钮。

PlaybackInteractor 监听启动、停止和终止事件，并调用 Player 对象的包装类的要求。当播放器通过状态更改进行回调时，它会更新事件总线上的播放状态。当需要终止时，它还会在服务上调用dismiss。

我在这个应用程序中没有 MediaBrowser 服务，因为我只有一个流，所以没有什么可浏览的，据我了解 BrowserService 是可选的。

非常感谢您在此问题上提供的任何帮助，我一直在尝试自行解决此问题，但除了死胡同外什么都没遇到，所以我希望有人在媒体框架方面有更多经验可以对此事有所了解。

【问题讨论】：

标签： android kotlin android-mediasession

【解决方案1】：

我无法让 MediaCallbacks 被调用，但我确实找到了另一个解决方案。

这并不理想，但不是依靠媒体框架来通知状态更改的回调，而是让服务拦截意图并自行解决。

override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
    handleIntent(intent)
    MediaButtonReceiver.handleIntent(mediaSession, intent)
    return START_NOT_STICKY
}

private fun handleIntent(intent: Intent) =
            (intent.extras?.get(Intent.EXTRA_KEY_EVENT) as KeyEvent?)?.keyCode.also {
            when (it) {
                KeyEvent.KEYCODE_MEDIA_PAUSE -> presenter.stopTapped()
                KeyEvent.KEYCODE_MEDIA_PLAY -> presenter.playTapped()
                KeyEvent.KEYCODE_MEDIA_STOP -> presenter.terminatePlayback()
            }
        }

虽然它的功能足以解除开发障碍，但也不是最漂亮的代码。

【讨论】：