android.support.v4.media.MediaBrowserCompat Java Examples

private MediaBrowserCompat.MediaItem createPlayableMediaItem(String mediaId, Uri musicSelection,
                                                             String title, @Nullable String subtitle,
                                                             @Nullable Bitmap albumArt, @Nullable Resources resources) {
    MediaDescriptionCompat.Builder builder = new MediaDescriptionCompat.Builder();
    builder.setMediaId(AutoMediaIDHelper.createMediaID(musicSelection.getPathSegments().get(PATH_SEGMENT_ID), mediaId))
            .setTitle(title);

    if (subtitle != null) {
        builder.setSubtitle(subtitle);
    }

    if (resources != null) {
        if (albumArt != null) {
            builder.setIconBitmap(albumArt);
        } else {
            builder.setIconUri(defaultAlbumArtUri);
        }
    }

    return new MediaBrowserCompat.MediaItem(builder.build(),
            MediaBrowserCompat.MediaItem.FLAG_PLAYABLE);
}
 

private void getLibrary(final Result<List<MediaBrowserCompat.MediaItem>> result) {
	new SilentServiceTask<List<MusicFolder>>(downloadService) {
		@Override
		protected List<MusicFolder> doInBackground(MusicService musicService) throws Throwable {
			return musicService.getMusicFolders(false, downloadService, null);
		}

		@Override
		protected void done(List<MusicFolder> folders) {
			List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

			for(MusicFolder folder: folders) {
				MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
						.setTitle(folder.getName())
						.setMediaId(MUSIC_FOLDER_PREFIX + folder.getId())
						.build();

				mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
			}

			result.sendResult(mediaItems);
		}
	}.execute();

	result.detach();
}
 

private void getPlaylists(final Result<List<MediaBrowserCompat.MediaItem>> result) {
	new SilentServiceTask<List<Playlist>>(downloadService) {
		@Override
		protected List<Playlist> doInBackground(MusicService musicService) throws Throwable {
			return musicService.getPlaylists(false, downloadService, null);
		}

		@Override
		protected void done(List<Playlist> playlists) {
			List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

			for(Playlist playlist: playlists) {
				MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
						.setTitle(playlist.getName())
						.setMediaId(PLAYLIST_PREFIX + playlist.getId())
						.build();

				mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
			}

			result.sendResult(mediaItems);
		}
	}.execute();

	result.detach();
}
 

private void getAlbumLists(Result<List<MediaBrowserCompat.MediaItem>> result) {
	List<Integer> albums = new ArrayList<>();
	albums.add(R.string.main_albums_newest);
	albums.add(R.string.main_albums_random);

	if(!Util.isTagBrowsing(downloadService)) {
		albums.add(R.string.main_albums_highest);
	}
	albums.add(R.string.main_albums_starred);
	albums.add(R.string.main_albums_recent);

	List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

	for(Integer id: albums) {
		MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
				.setTitle(downloadService.getResources().getString(id))
				.setMediaId(ALBUM_TYPE_PREFIX + id)
				.build();

		mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
	}

	result.sendResult(mediaItems);
}
 

@Override
public void onLoadChildren(@NonNull String parentId, @NonNull Result<List<MediaBrowserCompat.MediaItem>> result) {
    List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();
    ChannelDatabase channelDatabase = ChannelDatabase.getInstance(getApplicationContext());
    if (parentId.equals(MEDIA_ROOT_ID)) {
        try {
            for (Channel channel : channelDatabase.getChannels()) {
                MediaDescriptionCompat descriptionCompat = new MediaDescriptionCompat.Builder()
                        .setMediaId(channel.getInternalProviderData().getVideoUrl())
                        .setTitle(channel.getDisplayName())
                        .setIconUri(Uri.parse(channel.getChannelLogo()))
                        .setSubtitle(getString(R.string.channel_no_xxx, channel.getDisplayNumber()))
                        .setDescription(channel.getDescription())
                        .setMediaUri(Uri.parse(channel.getInternalProviderData().getVideoUrl()))
                        .build();
                mediaItems.add(new MediaBrowserCompat.MediaItem(descriptionCompat,
                        MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
            }
            result.sendResult(mediaItems);
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
}
 

private void getPodcasts(final Result<List<MediaBrowserCompat.MediaItem>> result) {
	new SilentServiceTask<List<PodcastChannel>>(downloadService) {
		@Override
		protected List<PodcastChannel> doInBackground(MusicService musicService) throws Throwable {
			return musicService.getPodcastChannels(false, downloadService, null);
		}

		@Override
		protected void done(List<PodcastChannel> podcasts) {
			List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

			for(PodcastChannel podcast: podcasts) {
				MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
						.setTitle(podcast.getName())
						.setMediaId(PODCAST_PREFIX + podcast.getId())
						.build();

				mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
			}

			result.sendResult(mediaItems);
		}
	}.execute();

	result.detach();
}
 

@Override
public void onLoadChildren(@NonNull String parentId,
                           @NonNull Result<List<MediaBrowserCompat.MediaItem>> result) {
    result.detach();
    Single.just(parentId)
            .map(id -> {
                if (parentId.startsWith(mRoot.getId())) {
                    return mRoot;
                } else {
                    return mEmptyRoot;
                }
            })
            .flatMap(directory -> directory.getContents(this, parentId))
            .subscribe(result::sendResult, throwable -> {
                Timber.e(throwable, "Failed to load media browser children");
                result.sendError(null);
            });
}
 

private List<MediaBrowserCompat.MediaItem> convertSongsToMediaItems(List<Song> songs) {
    List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();
    for (int i = 0; i < songs.size(); i++) {
        Song song = songs.get(i);
        mediaItems.add(new MediaBrowserCompat.MediaItem(
                new MediaDescriptionCompat.Builder()
                        .setMediaId(getIdForSong(song, i))
                        .setTitle(song.getSongName())
                        .setSubtitle(song.getArtistName())
                        .setDescription(song.getAlbumName())
                        .setMediaUri(song.getLocation())
                        .build(),
                MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
    }
    return mediaItems;
}
 

@Override
public void onLoadChildren(@NonNull final String parentId, @NonNull final Result<List<MediaBrowserCompat.MediaItem>> result) {
    if (AutoMediaIDHelper.MEDIA_ID_EMPTY_ROOT.equals(parentId)) {
        result.sendResult(new ArrayList<>());
    } else if (mMusicProvider.isInitialized()) {
        result.sendResult(mMusicProvider.getChildren(parentId, getResources()));
    } else {
        result.detach();
        mMusicProvider.retrieveMediaAsync(success -> result.sendResult(mMusicProvider.getChildren(parentId, getResources())));
    }
}
 

@Override
protected void onChildrenLoaded(@NonNull String parentId,
                                @NonNull List<MediaBrowserCompat.MediaItem> children) {
    super.onChildrenLoaded(parentId, children);

    final MediaControllerCompat mediaController = getMediaController();

    // Queue up all media items for this simple sample.
    for (final MediaBrowserCompat.MediaItem mediaItem : children) {
        mediaController.addQueueItem(mediaItem.getDescription());
    }

    // Call prepare now so pressing play just works.
    mediaController.getTransportControls().prepare();
}
 

@Override
public void onLoadChildren(String parentId,
                           Result<List<MediaBrowserCompat.MediaItem>> result) {
  // If you want to allow users to browse media content your app returns on
  // Android Auto or Wear OS, return those results here.
  result.sendResult(new ArrayList<MediaBrowserCompat.MediaItem>());
}
 

private void getRootFolders(Result<List<MediaBrowserCompat.MediaItem>> result) {
	List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

	MediaDescriptionCompat.Builder albumLists = new MediaDescriptionCompat.Builder();
	albumLists.setTitle(downloadService.getString(R.string.main_albums_title))
			.setMediaId(BROWSER_ALBUM_LISTS);
	mediaItems.add(new MediaBrowserCompat.MediaItem(albumLists.build(), MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));

	MediaDescriptionCompat.Builder library = new MediaDescriptionCompat.Builder();
	library.setTitle(downloadService.getString(R.string.button_bar_browse))
		.setMediaId(BROWSER_LIBRARY);
	mediaItems.add(new MediaBrowserCompat.MediaItem(library.build(), MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));

	MediaDescriptionCompat.Builder playlists = new MediaDescriptionCompat.Builder();
	playlists.setTitle(downloadService.getString(R.string.button_bar_playlists))
			.setMediaId(BROWSER_PLAYLISTS);
	mediaItems.add(new MediaBrowserCompat.MediaItem(playlists.build(), MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));

	//TODO, make this work, it currently crashes on auto
	/*if(Util.getPreferences(downloadService).getBoolean(Constants.PREFERENCES_KEY_PODCASTS_ENABLED, true)) {
		MediaDescriptionCompat.Builder podcasts = new MediaDescriptionCompat.Builder();
		podcasts.setTitle(downloadService.getString(R.string.button_bar_podcasts))
				.setMediaId(BROWSER_PODCASTS);
		mediaItems.add(new MediaBrowserCompat.MediaItem(podcasts.build(), MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
	}

	if(Util.getPreferences(downloadService).getBoolean(Constants.PREFERENCES_KEY_BOOKMARKS_ENABLED, true)) {
		MediaDescriptionCompat.Builder podcasts = new MediaDescriptionCompat.Builder();
		podcasts.setTitle(downloadService.getString(R.string.button_bar_bookmarks))
				.setMediaId(BROWSER_BOOKMARKS);
		mediaItems.add(new MediaBrowserCompat.MediaItem(podcasts.build(), MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
	}*/

	result.sendResult(mediaItems);
}
 

public static List<MediaBrowserCompat.MediaItem> getMediaItems() {
    List<MediaBrowserCompat.MediaItem> result = new ArrayList<>();
    for (MediaMetadataCompat metadata : music.values()) {
        result.add(
                new MediaBrowserCompat.MediaItem(
                        metadata.getDescription(), MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
    }
    return result;
}
 

private void getPodcastEpisodes(final Result<List<MediaBrowserCompat.MediaItem>> result, final String podcastId) {
	new SilentServiceTask<MusicDirectory>(downloadService) {
		@Override
		protected MusicDirectory doInBackground(MusicService musicService) throws Throwable {
			return musicService.getPodcastEpisodes(false, podcastId, downloadService, null);
		}

		@Override
		protected void done(MusicDirectory podcasts) {
			List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

			for(Entry entry: podcasts.getChildren(false, true)) {
				try {
					PodcastEpisode podcast = (PodcastEpisode) entry;
					Bundle podcastExtras = new Bundle();
					podcastExtras.putByteArray(Constants.INTENT_EXTRA_ENTRY_BYTES, podcast.toByteArray());
					podcastExtras.putString(Constants.INTENT_EXTRA_NAME_PODCAST_ID, podcast.getId());

					MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
							.setTitle(podcast.getTitle())
							.setSubtitle(Util.formatDate(downloadService, podcast.getDate(), false))
							.setMediaId(PODCAST_PREFIX + podcast.getId())
							.setExtras(podcastExtras)
							.build();

					mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
				} catch(IOException e) {
					Log.e(TAG, "Failed to add podcast", e);
				}
			}

			result.sendResult(mediaItems);
		}
	}.execute();

	result.detach();
}
 

private void getBookmarks(final Result<List<MediaBrowserCompat.MediaItem>> result) {
	new SilentServiceTask<MusicDirectory>(downloadService) {
		@Override
		protected MusicDirectory doInBackground(MusicService musicService) throws Throwable {
			return musicService.getBookmarks(false, downloadService, null);
		}

		@Override
		protected void done(MusicDirectory bookmarkList) {
			List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

			for(Entry entry: bookmarkList.getChildren(false, true)) {
				try {
					Bundle extras = new Bundle();
					extras.putByteArray(Constants.INTENT_EXTRA_ENTRY_BYTES, entry.toByteArray());
					extras.putString(Constants.INTENT_EXTRA_NAME_CHILD_ID, entry.getId());

					MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
							.setTitle(entry.getTitle())
							.setSubtitle(Util.formatDuration(entry.getBookmark().getPosition() / 1000))
							.setMediaId(entry.getId())
							.setExtras(extras)
							.build();

					mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
				} catch(IOException e) {
					Log.e(TAG, "Failed to add entry", e);
				}
			}

			result.sendResult(mediaItems);
		}
	}.execute();

	result.detach();
}
 

private static MediaBrowserCompat.MediaItem createBrowseableMediaItemForRoot(Resources resources) {
  MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
          .setMediaId(MEDIA_ID_MUSICS_BY_GENRE)
          //  .setTitle(resources.getString(R.string.browse_genres))
          //  .setSubtitle(resources.getString(R.string.browse_genre_subtitle))
          .build();
  return new MediaBrowserCompat.MediaItem(description,
          MediaBrowserCompat.MediaItem.FLAG_BROWSABLE);
}
 

@Override
protected final Single<List<MediaBrowserCompat.MediaItem>> getMedia() {
    return getSongs().map(this::convertSongsToMediaItems).map(mediaItems -> {
        mediaItems.add(0, new MediaBrowserCompat.MediaItem(
                new MediaDescriptionCompat.Builder()
                        .setMediaId(ENTRY_SHUFFLE_ALL)
                        .setTitle(mContext.getString(R.string.action_shuffle_all))
                        .build(),
                MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
        return mediaItems;
    });
}
 

private MediaBrowserCompat.MediaItem createPlayableMediaItem(String mediaId, String title, int iconDrawableId,
                                                             @Nullable String subtitle) {
    MediaDescriptionCompat.Builder builder = new MediaDescriptionCompat.Builder()
            .setMediaId(mediaId)
            .setTitle(title)
            .setIconBitmap(ImageUtil.createBitmap(ImageUtil.getTintedVectorDrawable(mContext, iconDrawableId, ThemeStore.textColorSecondary(mContext))));

    if (subtitle != null) {
        builder.setSubtitle(subtitle);
    }

    return new MediaBrowserCompat.MediaItem(builder.build(),
            MediaBrowserCompat.MediaItem.FLAG_PLAYABLE);
}
 

private void addPlayOptions(List<MediaBrowserCompat.MediaItem> mediaItems, String id, String idConstant) {
	Bundle playAllExtras = new Bundle();
	playAllExtras.putString(idConstant, id);

	MediaDescriptionCompat.Builder playAll = new MediaDescriptionCompat.Builder();
	playAll.setTitle(downloadService.getString(R.string.menu_play))
			.setMediaId("play-" + id)
			.setExtras(playAllExtras);
	mediaItems.add(new MediaBrowserCompat.MediaItem(playAll.build(), MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));

	Bundle shuffleExtras = new Bundle();
	shuffleExtras.putString(idConstant, id);
	shuffleExtras.putBoolean(Constants.INTENT_EXTRA_NAME_SHUFFLE, true);

	MediaDescriptionCompat.Builder shuffle = new MediaDescriptionCompat.Builder();
	shuffle.setTitle(downloadService.getString(R.string.menu_shuffle))
			.setMediaId("shuffle-" + id)
			.setExtras(shuffleExtras);
	mediaItems.add(new MediaBrowserCompat.MediaItem(shuffle.build(), MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));

	Bundle playLastExtras = new Bundle();
	playLastExtras.putString(idConstant, id);
	playLastExtras.putBoolean(Constants.INTENT_EXTRA_PLAY_LAST, true);

	MediaDescriptionCompat.Builder playLast = new MediaDescriptionCompat.Builder();
	playLast.setTitle(downloadService.getString(R.string.menu_play_last))
			.setMediaId("playLast-" + id)
			.setExtras(playLastExtras);
	mediaItems.add(new MediaBrowserCompat.MediaItem(playLast.build(), MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
}
 

private MediaBrowserCompat.MediaItem createBrowsableMediaItem(String mediaId, String title, int iconDrawableId) {
    MediaDescriptionCompat.Builder builder = new MediaDescriptionCompat.Builder();
    builder.setMediaId(mediaId)
            .setTitle(title)
            .setIconBitmap(ImageUtil.createBitmap(ImageUtil.getTintedVectorDrawable(mContext, iconDrawableId, ThemeStore.textColorSecondary(mContext))));

    return new MediaBrowserCompat.MediaItem(builder.build(),
            MediaBrowserCompat.MediaItem.FLAG_BROWSABLE);
}
 

public static List<MediaBrowserCompat.MediaItem> getChildren(String mediaId, Resources resources) {
  List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();
  if (!isBrowseable(mediaId)) {
    return mediaItems;
  }
  if (MEDIA_ID_ROOT.equals(mediaId)) {
    mediaItems.add(createBrowseableMediaItemForRoot(resources));
  }
  return mediaItems;
}
 

@Override
public void onLoadChildren(String parentId, Result<List<MediaBrowserCompat.MediaItem>> result) {
    result.sendResult(null);
}
 

@Override
public void onLoadChildren(
        @NonNull final String parentMediaId,
        @NonNull final Result<List<MediaBrowserCompat.MediaItem>> result) {
    result.sendResult(MusicLibrary.getMediaItems());
}
 

@Override
public void onLoadChildren(@NonNull String parentId, @NonNull Result<List<MediaBrowserCompat.MediaItem>> result) {
    result.sendResult(null);
}
 

@Override
public void onChildrenLoaded(@NonNull String parentId,
                             @NonNull List<MediaBrowserCompat.MediaItem> children) {
    MediaBrowserHelper.this.onChildrenLoaded(parentId, children);
}
 

private void getMusicDirectory(final Result<List<MediaBrowserCompat.MediaItem>> result, final String musicDirectoryId) {
	new SilentServiceTask<MusicDirectory>(downloadService) {
		@Override
		protected MusicDirectory doInBackground(MusicService musicService) throws Throwable {
			return musicService.getMusicDirectory(musicDirectoryId, "", false, downloadService, null);
		}

		@Override
		protected void done(MusicDirectory directory) {
			List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

			addPlayOptions(mediaItems, musicDirectoryId, Constants.INTENT_EXTRA_NAME_ID);

			for(Entry entry : directory.getChildren()) {
				MediaDescriptionCompat description;
				if (entry.isDirectory()) {
					// browse deeper
					description = new MediaDescriptionCompat.Builder()
							.setTitle(entry.getTitle())
							.setMediaId(MUSIC_DIRECTORY_CONTENTS_PREFIX + entry.getId())
							.build();

					mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
				} else {
					try {
						// mark individual songs as directly playable
						entry.setBookmark(null);    // don't resume from a bookmark in a browse listing
						Bundle extras = new Bundle();
						extras.putByteArray(Constants.INTENT_EXTRA_ENTRY_BYTES, entry.toByteArray());
						extras.putString(Constants.INTENT_EXTRA_NAME_CHILD_ID, entry.getId());

						description = new MediaDescriptionCompat.Builder()
								.setTitle(entry.getTitle())
								.setMediaId(entry.getId())
								.setExtras(extras)
								.build();

						mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_PLAYABLE));
					} catch (IOException e) {
						Log.e(TAG, "Failed to add entry", e);
					}
				}

			}
			result.sendResult(mediaItems);
		}
	}.execute();

	result.detach();
}
 

private void getAlbumList(final Result<List<MediaBrowserCompat.MediaItem>> result, final int id) {
	new SilentServiceTask<MusicDirectory>(downloadService) {
		@Override
		protected MusicDirectory doInBackground(MusicService musicService) throws Throwable {
			String albumListType;
			switch(id) {
				case R.string.main_albums_newest:
					albumListType = "newest";
					break;
				case R.string.main_albums_random:
					albumListType = "random";
					break;
				case R.string.main_albums_highest:
					albumListType = "highest";
					break;
				case R.string.main_albums_starred:
					albumListType = "starred";
					break;
				case R.string.main_albums_recent:
					albumListType = "recent";
					break;
				case R.string.main_albums_frequent:
					albumListType = "frequent";
					break;
				default:
					albumListType = "newest";
			}

			return musicService.getAlbumList(albumListType, 20, 0, true, downloadService, null);
		}

		@Override
		protected void done(MusicDirectory albumSet) {
			List<MediaBrowserCompat.MediaItem> mediaItems = new ArrayList<>();

			for(Entry album: albumSet.getChildren(true, false)) {
				MediaDescriptionCompat description = new MediaDescriptionCompat.Builder()
						.setTitle(album.getAlbumDisplay())
						.setSubtitle(album.getArtist())
						.setMediaId(MUSIC_DIRECTORY_PREFIX + album.getId())
						.build();

				mediaItems.add(new MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE));
			}

			result.sendResult(mediaItems);
		}
	}.execute();

	result.detach();
}
 

@Override
public void onLoadChildren(@NonNull String parentId, @NonNull Result<List<MediaBrowserCompat.MediaItem>> result) {
    result.sendResult(Collections.<MediaBrowserCompat.MediaItem>emptyList());
}
 

@Override
protected Single<List<MediaBrowserCompat.MediaItem>> getMedia() {
    return Single.just(Collections.emptyList());
}
 

@Override
protected Single<List<MediaBrowserCompat.MediaItem>> getMedia() {
    return Single.just(Collections.emptyList());
}