Controlli multimediali

I controlli multimediali in Android si trovano accanto alle Impostazioni rapide. Le sessioni di più app sono organizzate in un carosello a scorrimento. Il carosello elenca le sessioni in questo ordine:

  • Live streaming locali in riproduzione sul telefono
  • Stream remoti, ad esempio quelli rilevati su dispositivi esterni o sessioni di trasmissione
  • Sessioni precedenti ripristinabili, nell'ordine in cui sono state riprodotte l'ultima volta

A partire da Android 13 (livello API 33), per garantire che gli utenti possano accedere a un set multimediale di controlli multimediali per le app che riproducono contenuti multimediali, i pulsanti di azione sui controlli multimediali derivano dallo stato Player.

In questo modo, puoi presentare un insieme coerente di controlli multimediali e un'esperienza di controllo dei contenuti multimediali più curata su tutti i dispositivi.

La Figura 1 mostra un esempio dell'aspetto rispettivamente su uno smartphone e un tablet.

I controlli multimediali in termini di come vengono visualizzati su smartphone e tablet, utilizzando un esempio di una traccia di esempio che mostra l'aspetto dei pulsanti
Figura 1: controlli multimediali su smartphone e tablet

Il sistema mostra fino a cinque pulsanti di azione in base allo stato Player, come descritto nella seguente tabella. In modalità compatta, vengono visualizzati solo i primi tre slot di azione. in linea con il modo in cui i controlli multimediali vengono visualizzati in altre piattaforme Android, come Auto, Assistente e Wear OS.

Slot Criteri Azione
1 playWhenReady è false o lo stato di riproduzione corrente è STATE_ENDED. Gioca
playWhenReady è true e lo stato di riproduzione corrente è STATE_BUFFERING. Rotella di caricamento
playWhenReady è true e lo stato di riproduzione corrente è STATE_READY. Mettere in pausa
2 È disponibile il comando del player COMMAND_SEEK_TO_PREVIOUS o COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM. Precedente
Non è disponibile il comando del player COMMAND_SEEK_TO_PREVIOUSCOMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM ed è disponibile un comando personalizzato dal layout personalizzato che non è stato ancora inserito per riempire l'area annuncio. Personalizzato
(non ancora supportato con Media3) Gli elementi extra PlaybackState includono un valore booleano true per la chiave EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_PREV. Vuoto
3 È disponibile il comando del player COMMAND_SEEK_TO_NEXT o COMMAND_SEEK_TO_NEXT_MEDIA_ITEM. Avanti
Non è disponibile il comando del player COMMAND_SEEK_TO_NEXTCOMMAND_SEEK_TO_NEXT_MEDIA_ITEM ed è disponibile un comando personalizzato dal layout personalizzato che non è stato ancora inserito per riempire l'area annuncio. Personalizzato
(non ancora supportato con Media3) Gli elementi extra PlaybackState includono un valore booleano true per la chiave EXTRAS_KEY_SLOT_RESERVATION_SEEK_TO_NEXT. Vuoto
4 Nel layout personalizzato è disponibile un comando personalizzato che non è stato ancora inserito per riempire l'area annuncio. Personalizzato
5 Nel layout personalizzato è disponibile un comando personalizzato che non è stato ancora inserito per riempire l'area annuncio. Personalizzato

I comandi personalizzati vengono posizionati nell'ordine in cui sono stati aggiunti al layout personalizzato.

Personalizza i pulsanti di comando

Per personalizzare i controlli multimediali di sistema con Jetpack Media3, puoi impostare di conseguenza il layout personalizzato della sessione e i comandi disponibili dei controller durante l'implementazione di un MediaSessionService:

  1. In onCreate(), crea un MediaSession e definisci il layout personalizzato dei pulsanti di comando.

  2. In MediaSession.Callback.onConnect(), autorizza i controller definendo i comandi disponibili, inclusi i comandi personalizzati, in ConnectionResult.

  3. In MediaSession.Callback.onCustomCommand(), rispondi al comando personalizzato selezionato dall'utente.

Kotlin

class PlaybackService : MediaSessionService() {
  private val customCommandFavorites = SessionCommand(ACTION_FAVORITES, Bundle.EMPTY)
  private var mediaSession: MediaSession? = null

  override fun onCreate() {
    super.onCreate()
    val favoriteButton =
      CommandButton.Builder()
        .setDisplayName("Save to favorites")
        .setIconResId(R.drawable.favorite_icon)
        .setSessionCommand(customCommandFavorites)
        .build()
    val player = ExoPlayer.Builder(this).build()
    // Build the session with a custom layout.
    mediaSession =
      MediaSession.Builder(this, player)
        .setCallback(MyCallback())
        .setCustomLayout(ImmutableList.of(favoriteButton))
        .build()
  }

  private inner class MyCallback : MediaSession.Callback {
    override fun onConnect(
      session: MediaSession,
      controller: MediaSession.ControllerInfo
    ): ConnectionResult {
    // Set available player and session commands.
    return AcceptedResultBuilder(session)
      .setAvailablePlayerCommands(
        ConnectionResult.DEFAULT_PLAYER_COMMANDS.buildUpon()
          .remove(COMMAND_SEEK_TO_NEXT)
          .remove(COMMAND_SEEK_TO_NEXT_MEDIA_ITEM)
          .remove(COMMAND_SEEK_TO_PREVIOUS)
          .remove(COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM)
          .build()
      )
      .setAvailableSessionCommands(
        ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon()
          .add(customCommandFavorites)
          .build()
      )
      .build()
    }

    override fun onCustomCommand(
      session: MediaSession,
      controller: MediaSession.ControllerInfo,
      customCommand: SessionCommand,
      args: Bundle
    ): ListenableFuture {
      if (customCommand.customAction == ACTION_FAVORITES) {
        // Do custom logic here
        saveToFavorites(session.player.currentMediaItem)
        return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
      }
      return super.onCustomCommand(session, controller, customCommand, args)
    }
  }
}

Java

public class PlaybackService extends MediaSessionService {
  private static final SessionCommand CUSTOM_COMMAND_FAVORITES =
      new SessionCommand("ACTION_FAVORITES", Bundle.EMPTY);
  @Nullable private MediaSession mediaSession;

  public void onCreate() {
    super.onCreate();
    CommandButton favoriteButton =
        new CommandButton.Builder()
            .setDisplayName("Save to favorites")
            .setIconResId(R.drawable.favorite_icon)
            .setSessionCommand(CUSTOM_COMMAND_FAVORITES)
            .build();
    Player player = new ExoPlayer.Builder(this).build();
    // Build the session with a custom layout.
    mediaSession =
        new MediaSession.Builder(this, player)
            .setCallback(new MyCallback())
            .setCustomLayout(ImmutableList.of(favoriteButton))
            .build();
  }

  private static class MyCallback implements MediaSession.Callback {
    @Override
    public ConnectionResult onConnect(
        MediaSession session, MediaSession.ControllerInfo controller) {
      // Set available player and session commands.
      return new AcceptedResultBuilder(session)
          .setAvailablePlayerCommands(
              ConnectionResult.DEFAULT_PLAYER_COMMANDS.buildUpon()
                .remove(COMMAND_SEEK_TO_NEXT)
                .remove(COMMAND_SEEK_TO_NEXT_MEDIA_ITEM)
                .remove(COMMAND_SEEK_TO_PREVIOUS)
                .remove(COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM)
                .build())
          .setAvailableSessionCommands(
              ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon()
                .add(CUSTOM_COMMAND_FAVORITES)
                .build())
          .build();
    }

    public ListenableFuture onCustomCommand(
        MediaSession session,
        MediaSession.ControllerInfo controller,
        SessionCommand customCommand,
        Bundle args) {
      if (customCommand.customAction.equals(CUSTOM_COMMAND_FAVORITES.customAction)) {
        // Do custom logic here
        saveToFavorites(session.getPlayer().getCurrentMediaItem());
        return Futures.immediateFuture(new SessionResult(SessionResult.RESULT_SUCCESS));
      }
      return MediaSession.Callback.super.onCustomCommand(
          session, controller, customCommand, args);
    }
  }
}

Per scoprire di più sulla configurazione di MediaSession in modo che client come il sistema possano connettersi alla tua app multimediale, consulta Concedere il controllo ad altri client.

Con Jetpack Media3, quando implementi un elemento MediaSession, PlaybackState viene aggiornato automaticamente con il media player. Allo stesso modo, quando implementi un oggetto MediaSessionService, la libreria pubblica automaticamente una notifica MediaStyle per te e la mantiene aggiornata.

Rispondere ai pulsanti di azione

Quando un utente tocca un pulsante di azione nei controlli multimediali del sistema, l'MediaController del sistema invia un comando di riproduzione al tuo MediaSession. L'MediaSession delega quindi questi comandi al player. I comandi definiti nell'interfaccia Player di Media3 vengono gestiti automaticamente dalla sessione multimediale.

Consulta Aggiungere comandi personalizzati per istruzioni su come rispondere a un comando personalizzato.

Comportamento precedente ad Android 13

Per la compatibilità con le versioni precedenti, la UI di sistema continua a fornire un layout alternativo che utilizza le azioni di notifica per le app che non si aggiornano per avere come target Android 13 o che non includono informazioni su PlaybackState. I pulsanti di azione sono derivati dall'elenco Notification.Action allegato alla notifica MediaStyle. Il sistema mostra fino a cinque azioni nell'ordine in cui sono state aggiunte. In modalità compatta, vengono mostrati fino a tre pulsanti, determinati dai valori trasmessi a setShowActionsInCompactView().

Le azioni personalizzate vengono posizionate nell'ordine in cui sono state aggiunte a PlaybackState.

Il seguente esempio di codice illustra come aggiungere azioni alla notifica MediaStyle :

Kotlin

import androidx.core.app.NotificationCompat
import androidx.media3.session.MediaStyleNotificationHelper

var notification = NotificationCompat.Builder(context, CHANNEL_ID)
        // Show controls on lock screen even when user hides sensitive content.
        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
        .setSmallIcon(R.drawable.ic_stat_player)
        // Add media control buttons that invoke intents in your media service
        .addAction(R.drawable.ic_prev, "Previous", prevPendingIntent) // #0
        .addAction(R.drawable.ic_pause, "Pause", pausePendingIntent) // #1
        .addAction(R.drawable.ic_next, "Next", nextPendingIntent) // #2
        // Apply the media style template
        .setStyle(MediaStyleNotificationHelper.MediaStyle(mediaSession)
                .setShowActionsInCompactView(1 /* #1: pause button */))
        .setContentTitle("Wonderful music")
        .setContentText("My Awesome Band")
        .setLargeIcon(albumArtBitmap)
        .build()

Java

import androidx.core.app.NotificationCompat;
import androidx.media3.session.MediaStyleNotificationHelper;

NotificationCompat.Builder notification = new NotificationCompat.Builder(context, CHANNEL_ID)
        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
        .setSmallIcon(R.drawable.ic_stat_player)
        .addAction(R.drawable.ic_prev, "Previous", prevPendingIntent)
        .addAction(R.drawable.ic_pause, "Pause", pausePendingIntent)
        .addAction(R.drawable.ic_next, "Next", nextPendingIntent)
        .setStyle(new MediaStyleNotificationHelper.MediaStyle(mediaSession)
                .setShowActionsInCompactView(1 /* #1: pause button */))
        .setContentTitle("Wonderful music")
        .setContentText("My Awesome Band")
        .setLargeIcon(albumArtBitmap)
        .build();

Supporta la ripresa dei contenuti multimediali

La ripresa dei contenuti multimediali consente agli utenti di riavviare le sessioni precedenti dal carosello senza dover avviare l'app. All'avvio della riproduzione, l'utente interagisce con i controlli multimediali come di consueto.

La funzionalità di ripresa della riproduzione può essere attivata e disattivata tramite l'app Impostazioni, nelle opzioni Audio > Contenuti multimediali. L'utente può accedere alle Impostazioni anche toccando l'icona a forma di ingranaggio che appare dopo aver fatto scorrere il carosello espanso.

Media3 offre API per supportare più facilmente la ripresa dei contenuti multimediali. Consulta la documentazione relativa alla ripresa della riproduzione con Media3 per indicazioni sull'implementazione di questa funzionalità.

Utilizzo delle API multimediali legacy

Questa sezione spiega come eseguire l'integrazione con i controlli multimediali di sistema utilizzando le API MediaCompat legacy.

Il sistema recupera le seguenti informazioni dall'elemento MediaMetadata di MediaSession e le visualizza quando sono disponibili:

  • METADATA_KEY_ALBUM_ART_URI
  • METADATA_KEY_TITLE
  • METADATA_KEY_DISPLAY_TITLE
  • METADATA_KEY_ARTIST
  • METADATA_KEY_DURATION (se la durata non è impostata, la barra di scorrimento non mostra l'avanzamento)

Per assicurarti di ricevere una notifica di controllo dei contenuti multimediali valida e accurata, imposta il valore dei metadati METADATA_KEY_TITLE o METADATA_KEY_DISPLAY_TITLE sul titolo del contenuto multimediale attualmente in riproduzione.

Il media player mostra il tempo trascorso per il contenuto multimediale attualmente in riproduzione, insieme a una barra di ricerca mappata su MediaSession PlaybackState.

Il media player mostra l'avanzamento dei contenuti multimediali attualmente in riproduzione, insieme a una barra di ricerca mappata al MediaSession PlaybackState. La barra di ricerca consente agli utenti di modificare la posizione e visualizza il tempo trascorso per l'elemento multimediale. Per attivare la barra di scorrimento, devi implementare PlaybackState.Builder#setActions e includere ACTION_SEEK_TO.

Slot Azione Criteri
1 Gioca Lo stato attuale di PlaybackState è uno dei seguenti:
  • STATE_NONE
  • STATE_STOPPED
  • STATE_PAUSED
  • STATE_ERROR
Rotella di caricamento Lo stato attuale di PlaybackState è uno dei seguenti:
  • STATE_CONNECTING
  • STATE_BUFFERING
Mettere in pausa Lo stato attuale di PlaybackState non è nessuno dei valori precedenti.
2 Precedente PlaybackState azioni includono ACTION_SKIP_TO_PREVIOUS.
Personalizzato PlaybackState azioni non includono ACTION_SKIP_TO_PREVIOUS e PlaybackState azioni personalizzate includono un'azione personalizzata che non è stata ancora inserita.
Vuoto PlaybackState elementi extra includono un valore booleano true per la chiave SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_PREV.
3 Avanti PlaybackState azioni includono ACTION_SKIP_TO_NEXT.
Personalizzato PlaybackState azioni non includono ACTION_SKIP_TO_NEXT e PlaybackState azioni personalizzate includono un'azione personalizzata che non è stata ancora inserita.
Vuoto PlaybackState elementi extra includono un valore booleano true per la chiave SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT.
4 Personalizzato PlaybackState delle azioni personalizzate includono un'azione personalizzata che non è stata ancora inserita.
5 Personalizzato PlaybackState delle azioni personalizzate includono un'azione personalizzata che non è stata ancora inserita.

Aggiungi azioni standard

I seguenti esempi di codice illustrano come aggiungere le azioni standard e personalizzate di PlaybackState.

Per riproduzione, pausa, precedente e successivo, imposta queste azioni in PlaybackState per la sessione multimediale.

Kotlin

val session = MediaSessionCompat(context, TAG)
val playbackStateBuilder = PlaybackStateCompat.Builder()
val style = NotificationCompat.MediaStyle()

// For this example, the media is currently paused:
val state = PlaybackStateCompat.STATE_PAUSED
val position = 0L
val playbackSpeed = 1f
playbackStateBuilder.setState(state, position, playbackSpeed)

// And the user can play, skip to next or previous, and seek
val stateActions = PlaybackStateCompat.ACTION_PLAY
    or PlaybackStateCompat.ACTION_PLAY_PAUSE
    or PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
    or PlaybackStateCompat.ACTION_SKIP_TO_NEXT
    or PlaybackStateCompat.ACTION_SEEK_TO // adding the seek action enables seeking with the seekbar
playbackStateBuilder.setActions(stateActions)

// ... do more setup here ...

session.setPlaybackState(playbackStateBuilder.build())
style.setMediaSession(session.sessionToken)
notificationBuilder.setStyle(style)

Java

MediaSessionCompat session = new MediaSessionCompat(context, TAG);
PlaybackStateCompat.Builder playbackStateBuilder = new PlaybackStateCompat.Builder();
NotificationCompat.MediaStyle style = new NotificationCompat.MediaStyle();

// For this example, the media is currently paused:
int state = PlaybackStateCompat.STATE_PAUSED;
long position = 0L;
float playbackSpeed = 1f;
playbackStateBuilder.setState(state, position, playbackSpeed);

// And the user can play, skip to next or previous, and seek
long stateActions = PlaybackStateCompat.ACTION_PLAY
    | PlaybackStateCompat.ACTION_PLAY_PAUSE
    | PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
    | PlaybackStateCompat.ACTION_SKIP_TO_NEXT
    | PlaybackStateCompat.ACTION_SEEK_TO; // adding this enables the seekbar thumb
playbackStateBuilder.setActions(stateActions);

// ... do more setup here ...

session.setPlaybackState(playbackStateBuilder.build());
style.setMediaSession(session.getSessionToken());
notificationBuilder.setStyle(style);

Se non vuoi che siano presenti pulsanti negli slot precedenti o successivi, non aggiungere ACTION_SKIP_TO_PREVIOUS o ACTION_SKIP_TO_NEXT, ma aggiungi altri extra alla sessione:

Kotlin

session.setExtras(Bundle().apply {
    putBoolean(SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_PREV, true)
    putBoolean(SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT, true)
})

Java

Bundle extras = new Bundle();
extras.putBoolean(SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_PREV, true);
extras.putBoolean(SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT, true);
session.setExtras(extras);

Aggiungi azioni personalizzate

Per altre azioni che vuoi mostrare nei controlli multimediali, puoi creare un elemento PlaybackStateCompat.CustomAction e aggiungerlo a PlaybackState. Queste azioni vengono mostrate nell'ordine in cui sono state aggiunte.

Kotlin

val customAction = PlaybackStateCompat.CustomAction.Builder(
    "com.example.MY_CUSTOM_ACTION", // action ID
    "Custom Action", // title - used as content description for the button
    R.drawable.ic_custom_action
).build()

playbackStateBuilder.addCustomAction(customAction)

Java

PlaybackStateCompat.CustomAction customAction = new PlaybackStateCompat.CustomAction.Builder(
        "com.example.MY_CUSTOM_ACTION", // action ID
        "Custom Action", // title - used as content description for the button
        R.drawable.ic_custom_action
).build();

playbackStateBuilder.addCustomAction(customAction);

Risposta alle azioni RiproduzioneState

Quando un utente tocca un pulsante, SystemUI utilizza MediaController.TransportControls per inviare un comando a MediaSession. Devi registrare un callback che risponda correttamente a questi eventi.

Kotlin

val callback = object: MediaSession.Callback() {
    override fun onPlay() {
        // start playback
    }

    override fun onPause() {
        // pause playback
    }

    override fun onSkipToPrevious() {
        // skip to previous
    }

    override fun onSkipToNext() {
        // skip to next
    }

    override fun onSeekTo(pos: Long) {
        // jump to position in track
    }

    override fun onCustomAction(action: String, extras: Bundle?) {
        when (action) {
            CUSTOM_ACTION_1 -> doCustomAction1(extras)
            CUSTOM_ACTION_2 -> doCustomAction2(extras)
            else -> {
                Log.w(TAG, "Unknown custom action $action")
            }
        }
    }

}

session.setCallback(callback)

Java

MediaSession.Callback callback = new MediaSession.Callback() {
    @Override
    public void onPlay() {
        // start playback
    }

    @Override
    public void onPause() {
        // pause playback
    }

    @Override
    public void onSkipToPrevious() {
        // skip to previous
    }

    @Override
    public void onSkipToNext() {
        // skip to next
    }

    @Override
    public void onSeekTo(long pos) {
        // jump to position in track
    }

    @Override
    public void onCustomAction(String action, Bundle extras) {
        if (action.equals(CUSTOM_ACTION_1)) {
            doCustomAction1(extras);
        } else if (action.equals(CUSTOM_ACTION_2)) {
            doCustomAction2(extras);
        } else {
            Log.w(TAG, "Unknown custom action " + action);
        }
    }
};

Ripresa dei contenuti multimediali

Per far apparire la tua app del player nell'area delle impostazioni delle impostazioni rapide, devi creare una notifica MediaStyle con un token MediaSession valido.

Per visualizzare il titolo della notifica MediaStyle, usa NotificationBuilder.setContentTitle().

Per visualizzare l'icona del brand per il media player, utilizza NotificationBuilder.setSmallIcon().

Per supportare la ripresa della riproduzione, le app devono implementare MediaBrowserService e MediaSession. MediaSession deve implementare il callback onPlay().

Implementazione MediaBrowserService

Dopo l'avvio del dispositivo, il sistema cerca le cinque app multimediali utilizzate più di recente e fornisce controlli che possono essere utilizzati per riavviare la riproduzione da ogni app.

Il sistema tenta di contattare il tuo MediaBrowserService con una connessione da SystemUI. L'app deve consentire queste connessioni, altrimenti non supporta la ripresa della riproduzione.

Le connessioni da SystemUI possono essere identificate e verificate utilizzando il nome del pacchetto com.android.systemui e la firma. La SystemUI è firmata con la firma della piattaforma. Un esempio di come eseguire un controllo rispetto alla firma della piattaforma è disponibile nell'app UAMP.

Per supportare la ripresa della riproduzione, MediaBrowserService deve implementare i seguenti comportamenti:

  • onGetRoot() deve restituire rapidamente un valore root non-null. Altra logica complessa dovrebbe essere gestita in onLoadChildren()

  • Quando onLoadChildren() viene chiamato sull'ID del supporto principale, il risultato deve contenere un elemento secondario FLAG_PLAYABLE.

  • MediaBrowserService dovrebbe restituire l'elemento multimediale riprodotto più di recente quando riceve una query EXTRA_RECENT. Il valore restituito dovrebbe essere un elemento multimediale effettivo anziché una funzione generica.

  • MediaBrowserService deve fornire un valore MediaDescription appropriato con un titolo e un sottotitolo non vuoti. Dovrebbe inoltre impostare un URI icona o una bitmap icona.

I seguenti esempi di codice illustrano come implementare onGetRoot().

Kotlin

override fun onGetRoot(
    clientPackageName: String,
    clientUid: Int,
    rootHints: Bundle?
): BrowserRoot? {
    ...
    // Verify that the specified package is SystemUI. You'll need to write your 
    // own logic to do this.
    if (isSystem(clientPackageName, clientUid)) {
        rootHints?.let {
            if (it.getBoolean(BrowserRoot.EXTRA_RECENT)) {
                // Return a tree with a single playable media item for resumption.
                val extras = Bundle().apply {
                    putBoolean(BrowserRoot.EXTRA_RECENT, true)
                }
                return BrowserRoot(MY_RECENTS_ROOT_ID, extras)
            }
        }
        // You can return your normal tree if the EXTRA_RECENT flag is not present.
        return BrowserRoot(MY_MEDIA_ROOT_ID, null)
    }
    // Return an empty tree to disallow browsing.
    return BrowserRoot(MY_EMPTY_ROOT_ID, null)

Java

@Override
public BrowserRoot onGetRoot(String clientPackageName, int clientUid,
    Bundle rootHints) {
    ...
    // Verify that the specified package is SystemUI. You'll need to write your
    // own logic to do this.
    if (isSystem(clientPackageName, clientUid)) {
        if (rootHints != null) {
            if (rootHints.getBoolean(BrowserRoot.EXTRA_RECENT)) {
                // Return a tree with a single playable media item for resumption.
                Bundle extras = new Bundle();
                extras.putBoolean(BrowserRoot.EXTRA_RECENT, true);
                return new BrowserRoot(MY_RECENTS_ROOT_ID, extras);
            }
        }
        // You can return your normal tree if the EXTRA_RECENT flag is not present.
        return new BrowserRoot(MY_MEDIA_ROOT_ID, null);
    }
    // Return an empty tree to disallow browsing.
    return new BrowserRoot(MY_EMPTY_ROOT_ID, null);
}