Question

使用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是可选的。

在此问题上您能提供的任何帮助将不胜感激，我一直在尝试自己解决这个问题，但是除了死胡同之外，什么也没有，所以我希望有人能对Media Framework有更多的经验可以阐明这件事。

Answer 1

我无法让MediaCallbacks被呼叫，但是我确实找到了另一种解决方案。

这不是理想的选择，而是让服务拦截这些意图并自行解决，而不是依靠Media Framework来通知状态更改的回调。

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()
            }
        }

尽管功能最强大，但足以阻止开发。

如何使用Android MediaSessionCompat

1 个答案: