Hintergrundaudio in Android mit MediaSessionCompat

German (Deutsch) translation by Federicco Ancie (you can also view the original English article)

Eine der beliebtesten Anwendungen für mobile Geräte ist die Wiedergabe von Audio über Musik-Streaming-Dienste, heruntergeladene Podcasts oder eine beliebige andere Anzahl von Audioquellen. Dies ist zwar eine ziemlich häufige Funktion, ist jedoch schwer zu implementieren, da viele verschiedene Teile korrekt erstellt werden müssen, um Ihrem Benutzer das volle Android-Erlebnis zu bieten.

In diesem Tutorial erfahren Sie mehr über MediaSessionCompat aus der Android-Supportbibliothek und wie Sie damit einen geeigneten Hintergrundaudiodienst für Ihre Benutzer erstellen können.

Einrichten

Als erstes müssen Sie die Android-Supportbibliothek in Ihr Projekt aufnehmen. Dies können Sie tun, indem Sie die folgende Zeile in die Datei build.gradle Ihres Moduls unter dem Knoten Abhängigkeiten einfügen.

1	compile 'com.android.support:support-v13:24.2.1'

Nachdem Sie Ihr Projekt synchronisiert haben, erstellen Sie eine neue Java-Klasse. Für dieses Beispiel nenne ich die Klasse BackgroundAudioService. Diese Klasse muss MediaBrowserServiceCompat erweitern. Außerdem werden wir folgende Schnittstellen implementieren: MediaPlayer.OnCompletionListener und AudioManager.OnAudioFocusChangeListener.

Nachdem Ihre MediaBrowserServiceCompat-Implementierung jetzt erstellt wurde, nehmen wir uns einen Moment Zeit, um AndroidManifest.xml zu aktualisieren, bevor wir zu dieser Klasse zurückkehren. Oben in der Klasse müssen Sie die WAKE_LOCK-Berechtigung anfordern.

1	<uses-permission android:name="android.permission.WAKE_LOCK" />

Deklarieren Sie als Nächstes innerhalb des application-Knotens Ihren neuen Dienst mit den folgenden intent-filter-Elementen. Dadurch kann Ihr Dienst Steuertasten, Kopfhörerereignisse und das Durchsuchen von Medien für Geräte wie Android Auto abfangen (obwohl wir in diesem Tutorial nichts mit Android Auto tun werden, wird von MediaBrowserServiceCompat dennoch einige grundlegende Unterstützung dafür benötigt).

<service android:name=".BackgroundAudioService">
    <intent-filter>
        <action android:name="android.intent.action.MEDIA_BUTTON" />
        <action android:name="android.media.AUDIO_BECOMING_NOISY" />
        <action android:name="android.media.browse.MediaBrowserService" />
    </intent-filter>
</service>

Schließlich müssen Sie die Verwendung des MediaButtonReceiver aus der Android-Supportbibliothek deklarieren. Auf diese Weise können Sie Interaktionen mit Mediensteuerungstasten und Kopfhörerereignisse auf Geräten abfangen, auf denen KitKat und früher ausgeführt wird.

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

Nachdem Ihre AndroidManifest.xml-Datei fertig ist, können Sie sie schließen. Wir werden auch eine weitere Klasse namens MediaStyleHelper erstellen, die von Ian Lake, Developer Advocate bei Google, geschrieben wurde, um die Erstellung von Medienstilbenachrichtigungen zu bereinigen.

public class MediaStyleHelper {
    /**
     * Build a notification using the information from the given media session. Makes heavy use
     * of {@link MediaMetadataCompat#getDescription()} to extract the appropriate information.
     * @param context Context used to construct the notification.
     * @param mediaSession Media session to get information.
     * @return A pre-built notification with information from the given media session.
     */
    public static NotificationCompat.Builder from(
            Context context, MediaSessionCompat mediaSession) {
        MediaControllerCompat controller = mediaSession.getController();
        MediaMetadataCompat mediaMetadata = controller.getMetadata();
        MediaDescriptionCompat description = mediaMetadata.getDescription();

        NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
        builder
                .setContentTitle(description.getTitle())
                .setContentText(description.getSubtitle())
                .setSubText(description.getDescription())
                .setLargeIcon(description.getIconBitmap())
                .setContentIntent(controller.getSessionActivity())
                .setDeleteIntent(
                        MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_STOP))
                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC);
        return builder;
    }
}

Sobald das erstellt wurde, fahren Sie fort und schließen Sie die Datei. Wir werden uns im nächsten Abschnitt auf den Hintergrundaudiodienst konzentrieren.

Aufbau des Hintergrundaudiodienstes

Jetzt ist es an der Zeit, sich mit dem Kern der Erstellung Ihrer Medien-App zu befassen. Es gibt einige Membervariablen, die Sie zuerst für diese Beispiel-App deklarieren möchten: einen MediaPlayer für die eigentliche Wiedergabe und ein MediaSessionCompat-Objekt, das Metadaten und Wiedergabesteuerelemente/-zustände verwaltet.

1	private MediaPlayer mMediaPlayer;
2	private MediaSessionCompat mMediaSessionCompat;

Außerdem benötigen Sie einen BroadcastReceiver, der auf Änderungen des Kopfhörerstatus lauscht. Der Einfachheit halber hält dieser Receiver den MediaPlayer an, wenn er abgespielt wird.

private BroadcastReceiver mNoisyReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if( mMediaPlayer != null && mMediaPlayer.isPlaying() ) {
            mMediaPlayer.pause();
        }
    }
};

Für die letzte Membervariable erstellen Sie ein MediaSessionCompat.Callback-Objekt, das zum Behandeln des Wiedergabestatus verwendet wird, wenn Mediensitzungsaktionen auftreten.

private MediaSessionCompat.Callback mMediaSessionCallback = new MediaSessionCompat.Callback() {
    
    @Override
    public void onPlay() {
        super.onPlay();
    }

    @Override
    public void onPause() {
        super.onPause();
    }

    @Override
    public void onPlayFromMediaId(String mediaId, Bundle extras) {
        super.onPlayFromMediaId(mediaId, extras);
    }
};

Wir werden jede der oben genannten Methoden später in diesem Tutorial wiederholen, da sie verwendet werden, um Vorgänge in unserer Medien-App zu steuern.

Es gibt zwei Methoden, die wir ebenfalls deklarieren müssen, obwohl sie für die Zwecke dieses Tutorials nichts tun müssen: onGetRoot() und onLoadChildren(). Sie können den folgenden Code für Ihre Standardeinstellungen verwenden.

@Nullable
@Override
public BrowserRoot onGetRoot(@NonNull String clientPackageName, int clientUid, @Nullable Bundle rootHints) {
    if(TextUtils.equals(clientPackageName, getPackageName())) {
        return new BrowserRoot(getString(R.string.app_name), null);
    }

    return null;
}

//Not important for general audio service, required for class
@Override
public void onLoadChildren(@NonNull String parentId, @NonNull Result<List<MediaBrowserCompat.MediaItem>> result) {
    result.sendResult(null);
}

Schließlich möchten Sie die Methode onStartCommand() überschreiben, die den Einstiegspunkt in Ihren Service darstellt. Diese Methode nimmt den an den Service übergebenen Intent und sendet ihn an die MediaButtonReceiver-Klasse.

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    MediaButtonReceiver.handleIntent(mMediaSessionCompat, intent);
    return super.onStartCommand(intent, flags, startId);
}

Alle Dinge initialisieren

Nachdem Ihre Basiselementvariablen erstellt wurden, ist es an der Zeit, alles zu initialisieren. Dazu rufen wir verschiedene Hilfsmethoden in onCreate() auf.

@Override
public void onCreate() {
    super.onCreate();

    initMediaPlayer();
    initMediaSession();
    initNoisyReceiver();
}

Die erste Methode, initMediaPlayer(), initialisiert das MediaPlayer-Objekt, das wir oben in der Klasse erstellt haben, fordert einen teilweisen Wakelock an (weshalb wir diese Berechtigung in AndroidManifest.xml benötigt haben) und legt die Lautstärke des Players fest.

private void initMediaPlayer() {
    mMediaPlayer = new MediaPlayer();
    mMediaPlayer.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
    mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
    mMediaPlayer.setVolume(1.0f, 1.0f);
}

Mit der nächsten Methode, initMediaSession(), initialisieren wir das MediaSessionCompat-Objekt und verbinden es mit den Medienschaltflächen und Steuermethoden, die es uns ermöglichen, Wiedergabe und Benutzereingaben zu verarbeiten. Diese Methode beginnt mit dem Erstellen eines ComponentName-Objekts, das auf die MediaButtonReceiver-Klasse der Android-Supportbibliothek verweist, und verwendet diese zum Erstellen eines neuen MediaSessionCompat. Anschließend übergeben wir das zuvor erstellte MediaSession.Callback-Objekt und setzen die erforderlichen Flags zum Empfangen von Medientasteneingaben und Steuersignalen. Als Nächstes erstellen wir einen neuen Intent für die Verarbeitung von Medientasteneingaben auf Pre-Lollipop-Geräten und legen das Mediensitzungstoken für unseren Dienst fest.

private void initMediaSession() {
    ComponentName mediaButtonReceiver = new ComponentName(getApplicationContext(), MediaButtonReceiver.class);
    mMediaSessionCompat = new MediaSessionCompat(getApplicationContext(), "Tag", mediaButtonReceiver, null);

    mMediaSessionCompat.setCallback(mMediaSessionCallback);
    mMediaSessionCompat.setFlags( MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS | MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS );

    Intent mediaButtonIntent = new Intent(Intent.ACTION_MEDIA_BUTTON);
    mediaButtonIntent.setClass(this, MediaButtonReceiver.class);
    PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, mediaButtonIntent, 0);
    mMediaSessionCompat.setMediaButtonReceiver(pendingIntent);

    setSessionToken(mMediaSessionCompat.getSessionToken());
}

Schließlich registrieren wir den BroadcastReceiver, den wir oben in der Klasse erstellt haben, damit wir auf Kopfhörerwechselereignisse lauschen können.

private void initNoisyReceiver() {
    //Handles headphones coming unplugged. cannot be done through a manifest receiver
    IntentFilter filter = new IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
    registerReceiver(mNoisyReceiver, filter);
}

Umgang mit Audiofokus

Nachdem Sie die Initialisierung der BroadcastReceiver-, MediaSessionCompat- und MediaPlayer-Objekte abgeschlossen haben, ist es an der Zeit, sich mit der Handhabung des Audiofokus zu befassen.

Während wir vielleicht denken, dass unsere eigenen Audio-Apps derzeit die wichtigsten sind, konkurrieren andere Apps auf dem Gerät darum, ihre eigenen Sounds zu erzeugen, z. B. eine E-Mail-Benachrichtigung oder ein Handyspiel. Um mit diesen verschiedenen Situationen zu arbeiten, verwendet das Android-System den Audiofokus, um zu bestimmen, wie Audio behandelt werden soll.

Der erste Fall, den wir behandeln möchten, ist das Starten der Wiedergabe und der Versuch, den Fokus des Geräts zu erhalten. Gehen Sie in Ihrem MediaSessionCompat.Callback-Objekt in die Methode onPlay() und fügen Sie die folgende Bedingungsprüfung hinzu.

@Override
public void onPlay() {
    super.onPlay();
    if( !successfullyRetrievedAudioFocus() ) {
        return;
    }
}

Der obige Code ruft eine Hilfsmethode auf, die versucht, den Fokus abzurufen, und wenn dies nicht möglich ist, wird einfach zurückgegeben. In einer echten App möchten Sie die fehlgeschlagene Audiowiedergabe eleganter behandeln. successfullyRetrievedAudioFocus() ruft einen Verweis auf den AudioManager des Systems ab und versucht, den Audiofokus für das Streamen von Musik anzufordern. Es gibt dann einen boolean Wert zurück, der angibt, ob die Anforderung erfolgreich war oder nicht.

private boolean successfullyRetrievedAudioFocus() {
    AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);

    int result = audioManager.requestAudioFocus(this,
            AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
    
    return result == AudioManager.AUDIOFOCUS_GAIN;
}

Sie werden feststellen, dass wir this auch an die Methode requestAudioFocus() übergeben, die den OnAudioFocusChangeListener mit unserem Dienst verknüpft. Es gibt ein paar verschiedene Zustände, auf die Sie achten sollten, um ein "guter Bürger" im App-Ökosystem des Geräts zu sein.

AudioManager.AUDIOFOCUS_LOSS: Dies tritt auf, wenn eine andere App den Audiofokus angefordert hat. In diesem Fall sollten Sie die Audiowiedergabe in Ihrer App stoppen.
AudioManager.AUDIOFOCUS_LOSS_TRANSIENT: Dieser Zustand wird erreicht, wenn eine andere App Audio abspielen möchte, aber erwartet, dass sie nur für kurze Zeit fokussiert werden muss. Sie können diesen Status verwenden, um Ihre Audiowiedergabe zu unterbrechen.
AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: Wenn der Audio-Fokus angefordert wird, aber den Status "kann sich ducken" auslöst, bedeutet dies, dass Sie Ihre Wiedergabe fortsetzen können, die Lautstärke jedoch etwas verringern sollten. Dies kann auftreten, wenn ein Benachrichtigungston vom Gerät abgespielt wird.
AudioManager.AUDIOFOCUS_GAIN: Der letzte Zustand, den wir besprechen werden, ist AUDIOFOCUS_GAIN. Dies ist der Zustand, wenn eine Duckable-Audiowiedergabe abgeschlossen ist und Ihre App auf den vorherigen Ebenen fortgesetzt werden kann.

Ein vereinfachter onAudioFocusChange()-Callback kann wie folgt aussehen:

@Override
public void onAudioFocusChange(int focusChange) {
    switch( focusChange ) {
        case AudioManager.AUDIOFOCUS_LOSS: {
            if( mMediaPlayer.isPlaying() ) {
                mMediaPlayer.stop();
            }
            break;
        }
        case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT: {
            mMediaPlayer.pause();
            break;
        }
        case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: {
            if( mMediaPlayer != null ) {
                mMediaPlayer.setVolume(0.3f, 0.3f);
            }
            break;
        }
        case AudioManager.AUDIOFOCUS_GAIN: {
            if( mMediaPlayer != null ) {
                if( !mMediaPlayer.isPlaying() ) {
                    mMediaPlayer.start();
                }
                mMediaPlayer.setVolume(1.0f, 1.0f);
            }
            break;
        }
    }
}

Den MediaSessionCompat.Callback verstehen

Nachdem Sie nun eine allgemeine Struktur für Ihren Service erstellt haben, ist es an der Zeit, in den MediaSessionCompat.Callback einzutauchen. Im letzten Abschnitt haben Sie onPlay() ein wenig hinzugefügt, um zu überprüfen, ob der Audiofokus gewährt wurde. Unterhalb der bedingten Anweisung möchten Sie das MediaSessionCompat-Objekt auf aktiv setzen, ihm den Status STATE_PLAYING geben und die richtigen Aktionen zuweisen, die zum Erstellen von Pausenschaltflächen für Sperrbildschirm-Steuerelemente vor dem Lollipop, Telefon- und Android Wear-Benachrichtigungen erforderlich sind.

@Override
public void onPlay() {
    super.onPlay();
    if( !successfullyRetrievedAudioFocus() ) {
        return;
    }

    mMediaSessionCompat.setActive(true);
    setMediaPlaybackState(PlaybackStateCompat.STATE_PLAYING);
    
    ...
}

Die obige Methode setMediaPlaybackState() ist eine Hilfsmethode, die ein PlaybackStateCompat.Builder-Objekt erstellt und ihm die richtigen Aktionen und den richtigen Zustand zuweist und dann ein PlaybackStateCompat erstellt und Ihrem MediaSessionCompat-Objekt zuordnet.

private void setMediaPlaybackState(int state) {
    PlaybackStateCompat.Builder playbackstateBuilder = new PlaybackStateCompat.Builder();
    if( state == PlaybackStateCompat.STATE_PLAYING ) {
        playbackstateBuilder.setActions(PlaybackStateCompat.ACTION_PLAY_PAUSE | PlaybackStateCompat.ACTION_PAUSE);
    } else {
        playbackstateBuilder.setActions(PlaybackStateCompat.ACTION_PLAY_PAUSE | PlaybackStateCompat.ACTION_PLAY);
    }
    playbackstateBuilder.setState(state, PlaybackStateCompat.PLAYBACK_POSITION_UNKNOWN, 0);
    mMediaSessionCompat.setPlaybackState(playbackstateBuilder.build());
}

Beachten Sie, dass Sie in Ihren Aktionen sowohl das ACTION_PLAY_PAUSE- als auch das ACTION_PAUSE- oder ACTION_PLAY-Flag benötigen, um die richtige Steuerung auf Android Wear zu erhalten.

Zurück in onPlay() möchten Sie eine Wiedergabebenachrichtigung anzeigen, die Ihrem MediaSessionCompat-Objekt zugeordnet ist, indem Sie die zuvor definierte MediaStyleHelper-Klasse verwenden, und dann diese Benachrichtigung anzeigen.

private void showPlayingNotification() {
    NotificationCompat.Builder builder = MediaStyleHelper.from(BackgroundAudioService.this, mMediaSessionCompat);
    if( builder == null ) {
        return;
    }


    builder.addAction(new NotificationCompat.Action(android.R.drawable.ic_media_pause, "Pause", MediaButtonReceiver.buildMediaButtonPendingIntent(this, PlaybackStateCompat.ACTION_PLAY_PAUSE)));
    builder.setStyle(new NotificationCompat.MediaStyle().setShowActionsInCompactView(0).setMediaSession(mMediaSessionCompat.getSessionToken()));
    builder.setSmallIcon(R.mipmap.ic_launcher);
    NotificationManagerCompat.from(BackgroundAudioService.this).notify(1, builder.build());
}

Schließlich starten Sie den MediaPlayer am Ende von onPlay().

@Override
public void onPlay() {
    super.onPlay();

    ...

    showPlayingNotification();
    mMediaPlayer.start();
}

Media control notification on an Android Nougat device

Wenn der Callback einen Pause-Befehl erhält, wird onPause() aufgerufen. Hier pausieren Sie den MediaPlayer, setzen den Status auf STATE_PAUSED und zeigen eine pausierte Benachrichtigung an.

@Override
public void onPause() {
    super.onPause();

    if( mMediaPlayer.isPlaying() ) {
        mMediaPlayer.pause();
        setMediaPlaybackState(PlaybackStateCompat.STATE_PAUSED);
        showPausedNotification();
    }
}

Unsere showPausedNotification()-Hilfsmethode sieht ähnlich aus wie die showPlayNotification()-Methode.

private void showPausedNotification() {
    NotificationCompat.Builder builder = MediaStyleHelper.from(this, mMediaSessionCompat);
    if( builder == null ) {
        return;
    }

    builder.addAction(new NotificationCompat.Action(android.R.drawable.ic_media_play, "Play", MediaButtonReceiver.buildMediaButtonPendingIntent(this, PlaybackStateCompat.ACTION_PLAY_PAUSE)));
    builder.setStyle(new NotificationCompat.MediaStyle().setShowActionsInCompactView(0).setMediaSession(mMediaSessionCompat.getSessionToken()));
    builder.setSmallIcon(R.mipmap.ic_launcher);
    NotificationManagerCompat.from(this).notify(1, builder.build());
}

Die nächste Methode im Callback, die wir besprechen werden, onPlayFromMediaId(), verwendet einen String und ein Bundle als Parameter. Dies ist die Rückrufmethode, die Sie zum Ändern von Audiospuren/Inhalten in Ihrer App verwenden können.

Für dieses Tutorial akzeptieren wir einfach eine Rohressourcen-ID und versuchen, diese abzuspielen, und initialisieren dann die Metadaten der Sitzung neu. Da Sie ein Bundle an diese Methode übergeben dürfen, können Sie damit andere Aspekte Ihrer Medienwiedergabe anpassen, z. B. das Einrichten eines benutzerdefinierten Hintergrundsounds für einen Track.

@Override
public void onPlayFromMediaId(String mediaId, Bundle extras) {
    super.onPlayFromMediaId(mediaId, extras);

    try {
        AssetFileDescriptor afd = getResources().openRawResourceFd(Integer.valueOf(mediaId));
        if( afd == null ) {
            return;
        }

        try {
            mMediaPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());

        } catch( IllegalStateException e ) {
            mMediaPlayer.release();
            initMediaPlayer();
            mMediaPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
        }

        afd.close();
        initMediaSessionMetadata();

    } catch (IOException e) {
        return;
    }

    try {
        mMediaPlayer.prepare();
    } catch (IOException e) {}

    //Work with extras here if you want
}

Nachdem wir nun die beiden Hauptmethoden in diesem Rückruf besprochen haben, die Sie in Ihren Apps verwenden werden, ist es wichtig zu wissen, dass es andere optionale Methoden gibt, mit denen Sie Ihren Dienst anpassen können. Einige Methoden umfassen onSeekTo(), mit dem Sie die Wiedergabeposition Ihres Inhalts ändern können, und onCommand(), das einen String akzeptiert, der den Befehlstyp angibt, ein Bundle für zusätzliche Informationen zum Befehl und einen ResultReceiver-Rückruf, der ermöglicht es Ihnen, benutzerdefinierte Befehle an Ihren Service zu senden.

@Override
public void onCommand(String command, Bundle extras, ResultReceiver cb) {
    super.onCommand(command, extras, cb);
    if( COMMAND_EXAMPLE.equalsIgnoreCase(command) ) {
        //Custom command here
    }
}

@Override
public void onSeekTo(long pos) {
    super.onSeekTo(pos);
}

Abreißen

Wenn unsere Audiodatei fertig ist, möchten wir entscheiden, was unsere nächste Aktion sein wird. Während Sie vielleicht den nächsten Titel in Ihrer App abspielen möchten, halten wir die Dinge einfach und veröffentlichen den MediaPlayer.

@Override
public void onCompletion(MediaPlayer mediaPlayer) {
    if( mMediaPlayer != null ) {
        mMediaPlayer.release();
    }
}

Schließlich möchten wir noch ein paar Dinge in der onDestroy()-Methode unseres Service tun. Rufen Sie zunächst einen Verweis auf den AudioManager des Systemdienstes ab und rufen Sie AbandonAudioFocus() mit unserem AudioFocusChangeListener als Parameter auf, der andere Apps auf dem Gerät benachrichtigt, dass Sie den Audiofokus aufgeben. Heben Sie als Nächstes die Registrierung des BroadcastReceivers auf, der für die Überwachung von Kopfhöreränderungen eingerichtet wurde, und geben Sie das MediaSessionCompat-Objekt frei. Schließlich möchten Sie die Benachrichtigung zur Wiedergabesteuerung abbrechen.

@Override
public void onDestroy() {
    super.onDestroy();
    AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
    audioManager.abandonAudioFocus(this);
    unregisterReceiver(mNoisyReceiver);
    mMediaSessionCompat.release();
    NotificationManagerCompat.from(this).cancel(1);
}

An dieser Stelle sollten Sie über einen funktionierenden grundlegenden Hintergrundaudio Service verfügen, der MediaSessionCompat für die Wiedergabesteuerung auf allen Geräten verwendet. Während es bereits viel getan hat, um den Dienst zu erstellen, sollten Sie in der Lage sein, die Wiedergabe von Ihrer App, einer Benachrichtigung, einer Sperrbildschirmsteuerung auf Pre-Lollipop-Geräten (Lollipop und höher verwenden die Benachrichtigung auf dem Sperrbildschirm) zu steuern. und von Peripheriegeräten wie Android Wear, sobald der Service gestartet wurde.

Media lock screen controls on Android Kit Kat

Starten und Steuern von Inhalten aus einer Aktivität

Während die meisten Steuerelemente automatisch erfolgen, haben Sie noch ein wenig Arbeit, um eine Mediensitzung über Ihre In-App-Steuerelemente zu starten und zu steuern. Zumindest möchten Sie, dass in Ihrer App ein MediaBrowserCompat.ConnectionCallback-, MediaControllerCompat.Callback-, MediaBrowserCompat- und MediaControllerCompat-Objekt erstellt wird.

MediaControllerCompat.Callback verfügt über eine Methode namens onPlaybackStateChanged(), die Änderungen im Wiedergabestatus empfängt und verwendet werden kann, um Ihre Benutzeroberfläche synchron zu halten.

private MediaControllerCompat.Callback mMediaControllerCompatCallback = new MediaControllerCompat.Callback() {

    @Override
    public void onPlaybackStateChanged(PlaybackStateCompat state) {
        super.onPlaybackStateChanged(state);
        if( state == null ) {
            return;
        }
        
        switch( state.getState() ) {
            case PlaybackStateCompat.STATE_PLAYING: {
                mCurrentState = STATE_PLAYING;
                break;
            }
            case PlaybackStateCompat.STATE_PAUSED: {
                mCurrentState = STATE_PAUSED;
                break;
            }
        }
    }
};

MediaBrowserCompat.ConnectionCallback verfügt über eine onConnected()-Methode, die aufgerufen wird, wenn ein neues MediaBrowserCompat-Objekt erstellt und verbunden wird. Sie können dies verwenden, um Ihr MediaControllerCompat-Objekt zu initialisieren, es mit Ihrem MediaControllerCompat.Callback zu verknüpfen und es mit MediaSessionCompat von Ihrem Service zu verknüpfen. Sobald dies abgeschlossen ist, können Sie die Audiowiedergabe mit dieser Methode starten.

private MediaBrowserCompat.ConnectionCallback mMediaBrowserCompatConnectionCallback = new MediaBrowserCompat.ConnectionCallback() {

    @Override
    public void onConnected() {
        super.onConnected();
        try {
            mMediaControllerCompat = new MediaControllerCompat(MainActivity.this, mMediaBrowserCompat.getSessionToken());
            mMediaControllerCompat.registerCallback(mMediaControllerCompatCallback);
            setSupportMediaController(mMediaControllerCompat);
            getSupportMediaController().getTransportControls().playFromMediaId(String.valueOf(R.raw.warner_tautz_off_broadway), null);

        } catch( RemoteException e ) {

        }
    }
};

Sie werden feststellen, dass der obige Codeausschnitt getSupportMediaController().getTransportControls() verwendet, um mit der Mediensitzung zu kommunizieren. Mit derselben Technik können Sie onPlay() und onPause() im MediaSessionCompat.Callback-Objekt Ihres Audiodienstes aufrufen.

if( mCurrentState == STATE_PAUSED ) {
    getSupportMediaController().getTransportControls().play();
    mCurrentState = STATE_PLAYING;
} else {
    if( getSupportMediaController().getPlaybackState().getState() == PlaybackStateCompat.STATE_PLAYING ) {
        getSupportMediaController().getTransportControls().pause();
    }

    mCurrentState = STATE_PAUSED;
}

Wenn Sie mit der Audiowiedergabe fertig sind, können Sie den Audiodienst anhalten und Ihr MediaBrowserCompat-Objekt trennen, was wir in diesem Tutorial tun werden, wenn diese Activity zerstört wird.

@Override
protected void onDestroy() {
    super.onDestroy();
    if( getSupportMediaController().getPlaybackState().getState() == PlaybackStateCompat.STATE_PLAYING ) {
        getSupportMediaController().getTransportControls().pause();
    }

    mMediaBrowserCompat.disconnect();
}

Einpacken

Wütend! Wie Sie sehen können, gibt es viele bewegliche Teile, die mit der korrekten Erstellung und Verwendung eines Hintergrundaudiodienstes verbunden sind.

In diesem Tutorial haben Sie einen Dienst erstellt, der eine einfache Audiodatei abspielt, auf Änderungen des Audiofokus wartet und eine Verknüpfung zu MediaSessionCompat erstellt, um eine universelle Wiedergabesteuerung auf Android-Geräten, einschließlich Mobilteilen und Android Wear, bereitzustellen. Wenn Sie beim Durcharbeiten dieses Tutorials auf Hindernisse stoßen, empfehle ich dringend, den zugehörigen Android-Projektcode auf dem GitHub von Envato Tuts+ zu überprüfen.

Schauen Sie sich auch einige unserer anderen Android-Kurse und -Tutorials hier auf Envato Tuts+ an!