मीडिया कंट्रोल

Android में मीडिया कंट्रोल, क्विक सेटिंग के पास मौजूद होते हैं. इस तारीख से शुरू हुए सेशन स्वाइप किए जा सकने वाले कैरसेल में, कई ऐप्लिकेशन व्यवस्थित किए जाते हैं. कैरसेल में सेशन की सूची होती है इस क्रम में:

• फ़ोन पर चल रही स्ट्रीम
• रिमोट स्ट्रीम, जैसे कि वे स्ट्रीम जिन्हें बाहरी डिवाइसों या कास्ट सेशन पर स्ट्रीम किया गया है
• फिर से शुरू किए जा सकने वाले पिछले सेशन. इस क्रम में उन्हें पिछली बार चलाया गया था

यह Android 13 (एपीआई लेवल 33) से शुरू हो रहा है. इससे यह पक्का किया जा सकेगा कि उपयोगकर्ता मीडिया चलाने वाले ऐप्लिकेशन के लिए मीडिया कंट्रोल का सेट, मीडिया कंट्रोल पर ऐक्शन बटन Player से हासिल किए जाते हैं.

इस तरह, मीडिया कंट्रोल का एक जैसा सेट पेश किया जा सकता है. सभी डिवाइसों पर मीडिया कंट्रोल करने का अनुभव पाएँ.

पहली इमेज में दिखाया गया है कि यह फ़ोन और टैबलेट डिवाइस पर कैसा दिखता है. क्रम से.

Player स्थिति के आधार पर, सिस्टम ज़्यादा से ज़्यादा पांच ऐक्शन बटन इस तरह दिखाता है नीचे दी गई टेबल में बताया गया है. कॉम्पैक्ट मोड में, सिर्फ़ पहली तीन कार्रवाई स्लॉट प्रदर्शित होते हैं. यह इस बात से मेल खाता है कि मीडिया कंट्रोल किस तरह दूसरे प्लैटफ़ॉर्म पर रेंडर होते हैं Android प्लैटफ़ॉर्म, जैसे कि Auto, Assistant, और Wear OS.

पसंद के मुताबिक बनाए गए आदेश उसी क्रम में रखे जाते हैं जिस क्रम में उन्हें कस्टम लेआउट.

कमांड बटन को पसंद के मुताबिक बनाएं

Jetpack Media3 की मदद से, सिस्टम मीडिया कंट्रोल को पसंद के मुताबिक बनाने के लिए, आपके पास सेशन का कस्टम लेआउट और कंट्रोलर के हिसाब से, MediaSessionService को लागू करते समय:

1. onCreate() में, MediaSession बनाएं और कस्टम लेआउट तय करें दिखाई देती है.

2. MediaSession.Callback.onConnect() में, नियंत्रकों को उनके उपलब्ध निर्देश तय करके अनुमति देना. साथ ही, कस्टम निर्देश, ConnectionResult में.

3. MediaSession.Callback.onCustomCommand() में, उपयोगकर्ता के चुने गए कस्टम निर्देश का जवाब दें.

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

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

अपने MediaSession को कॉन्फ़िगर करने के बारे में ज़्यादा जानने के लिए, ताकि क्लाइंट को सिस्टम आपके मीडिया ऐप्लिकेशन से कनेक्ट हो सकता है, तो अन्य क्लाइंट को कंट्रोल दें.

Jetpack Media3 की मदद से MediaSession लागू करने पर, आपके PlaybackState को मीडिया प्लेयर के साथ अपने आप अप-टू-डेट रखा जाता है. इसी तरह, जब MediaSessionService लागू करने पर लाइब्रेरी, MediaStyle सूचना आपके लिए सही है और इसे अप-टू-डेट रखता है.

ऐक्शन बटन का जवाब देना

जब कोई उपयोगकर्ता सिस्टम के मीडिया कंट्रोल में ऐक्शन बटन पर टैप करता है, तो सिस्टम की MediaController आपके MediaSession को प्लेबैक निर्देश भेजता है. कॉन्टेंट बनाने इसके बाद, MediaSession उन कमांड को प्लेयर को सौंप देता है. निर्देश Media3 के Player में परिभाषित किया गया है इंटरफ़ेस को मीडिया अपने-आप मैनेज करता है सत्र.

कस्टम निर्देश जोड़ना लेख पढ़ें देखें.

Android 13 से पहले के वर्शन

पुराने सिस्टम के साथ काम करने की सुविधा के लिए, सिस्टम यूज़र इंटरफ़ेस (यूआई) एक वैकल्पिक लेआउट देना जारी रखता है जो उन ऐप्लिकेशन के लिए सूचना से जुड़ी कार्रवाइयों का इस्तेमाल करता है जिन्हें Android 13 को टारगेट करने के लिए अपडेट नहीं किया जाता है, या जिसमें PlaybackState की जानकारी शामिल नहीं होती. ऐक्शन बटन MediaStyle में अटैच की गई Notification.Action सूची से लिया गया है सूचना पर टैप करें. सिस्टम ज़्यादा से ज़्यादा पांच कार्रवाइयां उसी क्रम में दिखाता है जिस क्रम में वे जोड़े गए थे. कॉम्पैक्ट मोड में, ज़्यादा से ज़्यादा तीन बटन दिखाए जाते हैं. ये बटन setShowActionsInCompactView() में पास किए गए मान.

कस्टम ऐक्शन को उसी क्रम में रखा जाता है जिस क्रम में उन्हें PlaybackState.

उदाहरण के तौर पर दिया गया यह कोड दिखाता है कि MediaStyle में कार्रवाइयां कैसे जोड़ी जाएं सूचना :

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

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

मीडिया को फिर से शुरू करने में मदद करें

मीडिया को फिर से शुरू करने की सुविधा से उपयोगकर्ता, कैरसेल से पिछले सेशन को रीस्टार्ट कर सकते हैं और ऐप को चालू करने की ज़रूरत नहीं है. जब प्लेबैक शुरू होता है, तो उपयोगकर्ता मीडिया कंट्रोल को सामान्य तरीके से ट्रैक करता है.

वीडियो को फिर से चलाने की सुविधा को सेटिंग ऐप्लिकेशन, सेटिंग ऐप्लिकेशन, आवाज़ > मीडिया विकल्प. उपयोगकर्ता नीचे दिए गए विकल्पों का इस्तेमाल करके भी सेटिंग को ऐक्सेस कर सकते हैं बड़ा किए गए कैरसेल पर स्वाइप करने के बाद दिखने वाले गियर आइकॉन पर टैप करें.

Media3, एपीआई की सुविधा देता है. इससे मीडिया को दोबारा चलाने में मदद मिलती है. ज़्यादा जानकारी के लिए, Media3 की मदद से वीडियो को फिर से शुरू करना इस सुविधा को लागू करने के बारे में दिशा-निर्देश के लिए दस्तावेज़.

लेगसी मीडिया एपीआई का इस्तेमाल करना

इस सेक्शन में बताया गया है कि लेगसी MediaCompat API का इस्तेमाल करें.

सिस्टम नीचे दी गई जानकारी को MediaSession का MediaMetadata और इसके उपलब्ध होने पर यह दिखता है:

• METADATA_KEY_ALBUM_ART_URI
• METADATA_KEY_TITLE
• METADATA_KEY_DISPLAY_TITLE
• METADATA_KEY_ARTIST
• METADATA_KEY_DURATION (अगर अवधि सेट नहीं है, तो सीक (आगे/पीछे ले जाने वाला) बार प्रोग्रेस दिखाएं)

यह पक्का करने के लिए कि आपके पास मीडिया कंट्रोल की सटीक और मान्य सूचना है, METADATA_KEY_TITLE या METADATA_KEY_DISPLAY_TITLE का मान सेट करें अभी चल रहे मीडिया के टाइटल का मेटाडेटा.

मीडिया प्लेयर, चल रहे मौजूदा वीडियो के लिए बीता हुआ समय दिखाता है मीडिया और सीक (आगे/पीछे ले जाने वाला) बार, जिसे MediaSession के साथ मैप किया गया है PlaybackState.

मीडिया प्लेयर, चल रहे मीडिया की प्रोग्रेस दिखाता है. साथ ही, यह जानकारी भी दिखाता है कि सीक बार, जिसे MediaSession PlaybackState पर मैप किया गया है. सीक (आगे/पीछे ले जाने वाला) बार उपयोगकर्ताओं को मीडिया की स्थिति बदलने देता है और मीडिया के लिए बीता हुआ समय दिखाता है आइटम. सीक बार को चालू करने के लिए, आपको इन चीज़ों को लागू करना होगा PlaybackState.Builder#setActions और ACTION_SEEK_TO शामिल हैं.

स्टैंडर्ड कार्रवाइयां जोड़ें

नीचे दिए गए कोड उदाहरणों में, PlaybackState स्टैंडर्ड और कस्टम ऐक्शन.

चलाने, रोकने, पिछली, और आगे चलाने के लिए, इन कार्रवाइयों को मीडिया सेशन के लिए PlaybackState.

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)

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);

अगर आपको पिछले या अगले स्लॉट में कोई बटन नहीं चाहिए, तो न जोड़ें ACTION_SKIP_TO_PREVIOUS या ACTION_SKIP_TO_NEXT. इसके बजाय, इसमें अतिरिक्त जोड़ें सत्र:

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

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);

कस्टम कार्रवाइयां जोड़ें

दूसरी कार्रवाइयां जिन्हें आपको मीडिया कंट्रोलर पर दिखाना है उनके लिए, PlaybackStateCompat.CustomAction और उसे PlaybackState में जोड़ दें. ये कार्रवाइयां इसमें दिखती हैं जिस क्रम में उन्हें जोड़ा गया.

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)

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);

PLAYState कार्रवाइयों का जवाब दिया जा रहा है

जब कोई उपयोगकर्ता किसी बटन पर टैप करता है, तो SystemUI, MediaController.TransportControls MediaSession को निर्देश वापस भेजने के लिए. आपको कॉलबैक रजिस्टर करना होगा जो इन इवेंट का सही ढंग से जवाब दे सकें.

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)

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

मीडिया को फिर से शुरू करना

क्विक सेटिंग की सेटिंग वाली जगह में अपना प्लेयर ऐप्लिकेशन दिखाने के लिए, आपको मान्य MediaSession टोकन के साथ, MediaStyle सूचना बनानी होगी.

MediaStyle नोटिफ़िकेशन का शीर्षक दिखाने के लिए, इसका इस्तेमाल करें NotificationBuilder.setContentTitle().

मीडिया प्लेयर का ब्रैंड आइकॉन दिखाने के लिए, इसका इस्तेमाल करें NotificationBuilder.setSmallIcon().

वीडियो को फिर से चलाने के लिए, ऐप्लिकेशन को MediaBrowserService लागू करना होगा और MediaSession. आपके MediaSession को onPlay() कॉलबैक लागू करना होगा.

MediaBrowserService लागू करना

डिवाइस के बूट होने के बाद, सिस्टम सबसे हाल ही में इस्तेमाल किए गए पांच मीडिया को खोजता है साथ ही, उससे जुड़े कंट्रोल मिलते हैं. इनका इस्तेमाल करके, किसी ऐप्लिकेशन से दोबारा चलाना शुरू किया जा सकता है.

सिस्टम, आपके MediaBrowserService से कनेक्ट करके, उनसे संपर्क करने की कोशिश करता है: SystemUI. आपके ऐप्लिकेशन को ऐसे कनेक्शन की अनुमति देनी होगी. ऐसा न होने पर, वह उसे फिर से शुरू करना.

SystemUI से कनेक्शन की पहचान करने और उनकी पुष्टि करने के लिए, पैकेज के नाम का इस्तेमाल किया जा सकता है com.android.systemui और हस्ताक्षर. SystemUI को प्लैटफ़ॉर्म से साइन किया गया है हस्ताक्षर करें. प्लैटफ़ॉर्म सिग्नेचर की जांच कैसे करें, इसका एक उदाहरण यह हो सकता है: Uएएमपी ऐप्लिकेशन में मिलता है.

वीडियो को फिर से शुरू करने के लिए, आपके MediaBrowserService के लिए यह ज़रूरी है ये व्यवहार लागू करें:

• onGetRoot() को तुरंत एक ऐसी रूट वैल्यू देनी होगी जो शून्य नहीं है. अन्य जटिल लॉजिक को onLoadChildren() में हैंडल किया जाएगा

• टास्क कब शुरू होगा onLoadChildren() को रूट मीडिया आईडी पर कॉल किया जाता है, नतीजे में FLAG_PLAYABLE बच्चा.

• MediaBrowserService को सबसे हाल ही में चलाया गया मीडिया आइटम लौटाना चाहिए, जब तो उन्हें एक्सट्रैक्शन क्वेरी. वापस दिया गया मान सामान्य के बजाय एक वास्तविक मीडिया आइटम होना चाहिए फ़ंक्शन का इस्तेमाल करना होगा.

• MediaBrowserService में सही जानकारी देनी होगी MediaDescription खाली नहीं है टाइटल और सबटाइटल. इससे यह भी सेट करना चाहिए कि आइकॉन यूआरआई या एक आइकॉन बिटमैप के साथ दिखेगा.

नीचे दिए गए कोड के उदाहरणों में, onGetRoot() को लागू करने का तरीका बताया गया है.

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)

@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);
}