import android.media.MediaMetadata; //导入依赖的package包/类
/**
 * Update title and pic on now playing card
 */
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private void updateNowPlayingMetadata() {
    MediaMetadata.Builder metadataBuilder = new MediaMetadata.Builder();
    String title = mVideoInfo.scraperTitle!=null?mVideoInfo.scraperTitle:mVideoInfo.title!=null?mVideoInfo.title:Utils.getFileNameWithoutExtension(mUri);
    metadataBuilder.putString(MediaMetadata.METADATA_KEY_DISPLAY_TITLE,
            title);
    metadataBuilder.putString(MediaMetadata.METADATA_KEY_TITLE,title);
    metadataBuilder.putString(MediaMetadata.METADATA_KEY_DISPLAY_ICON_URI,
            mVideoInfo.scraperCover);
    Bitmap bitmap = BitmapFactory.decodeFile(mVideoInfo.scraperCover);
    if (bitmap == null&&mVideoInfo.id >= 0) { //if no scrapped poster, try to get a thumbnail
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = 2;
        bitmap = VideoStore.Video.Thumbnails.getThumbnail(getContentResolver(),mVideoInfo.id, VideoStore.Video.Thumbnails.MINI_KIND, options);
    }
    if (bitmap == null) {
        bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.widget_default_video);
    }
    metadataBuilder.putBitmap(MediaMetadata.METADATA_KEY_ART, bitmap);
    mSession.setMetadata(metadataBuilder.build());
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
private void updateMediaSession(int state) {

        MediaMetadata.Builder mediaBuilder = null;

        Bitmap bitmap = null;
        try {
            URL url = new URL(mRadioIcon);
            bitmap = BitmapFactory.decodeStream(url.openConnection().getInputStream());
        } catch (IOException e) {
            Log.e(TAG, "BitmapFactory.decodeStream", e);
        }

        mediaBuilder = new MediaMetadata.Builder();
        mediaBuilder.putString(MediaMetadata.METADATA_KEY_TITLE, mTitle);
        if (bitmap != null) {
            mediaBuilder.putBitmap(MediaMetadata.METADATA_KEY_ART, bitmap);
        }

        mMediaSession.setMetadata(mediaBuilder.build());

        PlaybackState.Builder stateBuilder = new PlaybackState.Builder();
        stateBuilder.setState(state, 0, 1.0f);

        mMediaSession.setPlaybackState(stateBuilder.build());
    }
 

import android.media.MediaMetadata; //导入依赖的package包/类
private void updateMetadata(final Movie movie) {
    final MediaMetadata.Builder metadataBuilder = new MediaMetadata.Builder();

    String title = movie.getTitle().replace("_", " -");

    metadataBuilder.putString(MediaMetadata.METADATA_KEY_DISPLAY_TITLE, title);
    metadataBuilder.putString(MediaMetadata.METADATA_KEY_DISPLAY_SUBTITLE,
            movie.getDescription());
    metadataBuilder.putString(MediaMetadata.METADATA_KEY_DISPLAY_ICON_URI,
            movie.getCardImageUrl());

    // And at minimum the title and artist for legacy support
    metadataBuilder.putString(MediaMetadata.METADATA_KEY_TITLE, title);
    metadataBuilder.putString(MediaMetadata.METADATA_KEY_ARTIST, movie.getStudio());

    Glide.with(this)
            .load(Uri.parse(movie.getCardImageUrl()))
            .asBitmap()
            .into(new SimpleTarget<Bitmap>(500, 500) {
                @Override
                public void onResourceReady(Bitmap bitmap, GlideAnimation anim) {
                    metadataBuilder.putBitmap(MediaMetadata.METADATA_KEY_ART, bitmap);
                    mSession.setMetadata(metadataBuilder.build());
                }
            });
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
@Override
public void onMetadataChanged(MediaMetadata metadata) {
    super.onMetadataChanged(metadata);

    if (metadata != null) {
        mDevice.write(mediaArtistCharac,
                getTextAsBytes(metadata, MediaMetadata.METADATA_KEY_ARTIST),
                MediaService.this);

        mDevice.write(mediaAlbumCharac,
                getTextAsBytes(metadata, MediaMetadata.METADATA_KEY_ALBUM),
                MediaService.this);

        mDevice.write(mediaTitleCharac,
                getTextAsBytes(metadata, MediaMetadata.METADATA_KEY_TITLE),
                MediaService.this);
    }
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
private void updateMediaMetadata(final long programId, final String title,
        final String subtitle, final long duration,
        final Bitmap posterArt, final int imageResId) {
    new AsyncTask<Void, Void, Void>() {
        @Override
        protected Void doInBackground(Void... arg0) {
            MediaMetadata.Builder builder = new MediaMetadata.Builder();
            builder.putLong(MediaMetadata.METADATA_KEY_MEDIA_ID, programId)
                    .putString(MediaMetadata.METADATA_KEY_TITLE, title)
                    .putLong(MediaMetadata.METADATA_KEY_DURATION, duration);
            if (subtitle != null) {
                builder.putString(MediaMetadata.METADATA_KEY_DISPLAY_SUBTITLE, subtitle);
            }
            Bitmap programPosterArt = posterArt;
            if (programPosterArt == null && imageResId != 0) {
                programPosterArt =
                        BitmapFactory.decodeResource(mActivity.getResources(), imageResId);
            }
            if (programPosterArt != null) {
                builder.putBitmap(MediaMetadata.METADATA_KEY_ART, programPosterArt);
            }
            mMediaSession.setMetadata(builder.build());
            return null;
        }
    }.execute();
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
@Test
public void fromMediaMetadata() {
  MediaMetadata input =
      new MediaMetadata.Builder()
          .putString(MediaMetadata.METADATA_KEY_TITLE, "Title")
          .putString(MediaMetadata.METADATA_KEY_ARTIST, "Artist")
          .putString(MediaMetadata.METADATA_KEY_ALBUM, "Album")
          .putString(MediaMetadata.METADATA_KEY_ALBUM_ARTIST, "Album Artist")
          .putBitmap(MediaMetadata.METADATA_KEY_ART, EMPTY_BITMAP)
          .putLong(MediaMetadata.METADATA_KEY_DURATION, 10000)
          .build();

  Track output = Track.fromMediaMetadata(input);

  assertThat(output.track()).isEqualTo("Title");
  assertThat(output.artist()).isEqualTo("Artist");
  assertThat(output.albumArtist()).hasValue("Album Artist");
  assertThat(output.art()).isPresent();
  assertThat(output.duration()).hasValue((long) 10000);
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
@Test
public void fromMediaMetadata_generatesInvalidTrackWhenNoArtistOrTitle() {
  MediaMetadata empty = new MediaMetadata.Builder().build();
  MediaMetadata noTitle =
      new MediaMetadata.Builder().putString(MediaMetadata.METADATA_KEY_ARTIST, "Artist").build();
  MediaMetadata noArtist =
      new MediaMetadata.Builder().putString(MediaMetadata.METADATA_KEY_TITLE, "Title").build();

  Track output1 = Track.fromMediaMetadata(empty);
  Track output2 = Track.fromMediaMetadata(noTitle);
  Track output3 = Track.fromMediaMetadata(noArtist);

  assertThat(output1.isValid()).isFalse();
  assertThat(output2.isValid()).isFalse();
  assertThat(output3.isValid()).isFalse();
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
@Test
public void fromMediaMetadata_translatesShortDurationsToMilliseconds() {
  long threeMinutesSeconds = 4 * 60;
  long threeMinutesMs = 4 * 60 * 1000;
  MediaMetadata millisecondsInput =
      new MediaMetadata.Builder()
          .putLong(MediaMetadata.METADATA_KEY_DURATION, threeMinutesMs)
          .build();
  MediaMetadata secondsInput =
      new MediaMetadata.Builder()
          .putLong(MediaMetadata.METADATA_KEY_DURATION, threeMinutesSeconds)
          .build();

  Track output1 = Track.fromMediaMetadata(millisecondsInput);
  Track output2 = Track.fromMediaMetadata(secondsInput);

  assertThat(output1.duration()).hasValue(threeMinutesMs);
  assertThat(output2.duration()).hasValue(threeMinutesMs);
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
private void updateMediaSessionMetaData() {
    if (mCurrentMediaItem == null) {
        throw new IllegalArgumentException(
                "mCurrentMediaItem is null in updateMediaSessionMetaData!");
    }
    MediaMetadataCompat.Builder metaDataBuilder = new MediaMetadataCompat.Builder();
    if (mCurrentMediaItem.getMediaTitle() != null) {
        metaDataBuilder.putString(MediaMetadata.METADATA_KEY_TITLE,
                mCurrentMediaItem.getMediaTitle());
    }
    if (mCurrentMediaItem.getMediaAlbumName() != null) {
        metaDataBuilder.putString(MediaMetadata.METADATA_KEY_ALBUM,
                mCurrentMediaItem.getMediaAlbumName());
    }
    if (mCurrentMediaItem.getMediaArtistName() != null) {
        metaDataBuilder.putString(MediaMetadata.METADATA_KEY_ARTIST,
                mCurrentMediaItem.getMediaArtistName());
    }
    if (mCurrentMediaItem.getMediaAlbumArtResId() != 0) {
        Bitmap albumArtBitmap = BitmapFactory.decodeResource(getResources(),
                mCurrentMediaItem.getMediaAlbumArtResId());
        metaDataBuilder.putBitmap(MediaMetadata.METADATA_KEY_ALBUM_ART, albumArtBitmap);
    }
    mMediaSession.setMetadata(metaDataBuilder.build());
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
@Override
public void onCustomAction(@NonNull String action, Bundle extras) {
    if (CUSTOM_ACTION_THUMBS_UP.equals(action)) {
        LogHelper.i(TAG, "onCustomAction: favorite for current track");
        MediaMetadata track = getCurrentPlayingMusic();
        if (track != null) {
            String musicId = track.getString(MediaMetadata.METADATA_KEY_MEDIA_ID);
            mMusicProvider.setFavorite(musicId, !mMusicProvider.isFavorite(musicId));
        }
        // playback state needs to be updated because the "Favorite" icon on the
        // custom action will change to reflect the new favorite state.
        updatePlaybackState(null);
    } else {
        LogHelper.e(TAG, "Unsupported action: ", action);
    }
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
private void setCustomAction(PlaybackState.Builder stateBuilder) {
    MediaMetadata currentMusic = getCurrentPlayingMusic();
    if (currentMusic != null) {
        // Set appropriate "Favorite" icon on Custom action:
        String musicId = currentMusic.getString(MediaMetadata.METADATA_KEY_MEDIA_ID);
        int favoriteIcon = R.drawable.ic_star_off;
        if (mMusicProvider.isFavorite(musicId)) {
            favoriteIcon = R.drawable.ic_star_on;
        }
        LogHelper.d(TAG, "updatePlaybackState, setting Favorite custom action of music ",
                musicId, " current favorite=", mMusicProvider.isFavorite(musicId));
        Bundle customActionExtras = new Bundle();
        WearHelper.setShowCustomActionOnWear(customActionExtras, true);
        stateBuilder.addCustomAction(new PlaybackState.CustomAction.Builder(
                CUSTOM_ACTION_THUMBS_UP, getString(R.string.favorite), favoriteIcon)
                .setExtras(customActionExtras)
                .build());
    }
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
private static List<MediaSession.QueueItem> convertToQueue(
        Iterable<MediaMetadata> tracks, String... categories) {
    List<MediaSession.QueueItem> queue = new ArrayList<>();
    int count = 0;
    for (MediaMetadata track : tracks) {

        // We create a hierarchy-aware mediaID, so we know what the queue is about by looking
        // at the QueueItem media IDs.
        String hierarchyAwareMediaID = MediaIDHelper.createMediaID(
                track.getDescription().getMediaId(), categories);

        MediaMetadata trackCopy = new MediaMetadata.Builder(track)
                .putString(MediaMetadata.METADATA_KEY_MEDIA_ID, hierarchyAwareMediaID)
                .build();

        // We don't expect queues to change after created, so we use the item index as the
        // queueId. Any other number unique in the queue would work.
        MediaSession.QueueItem item = new MediaSession.QueueItem(
                trackCopy.getDescription(), count++);
        queue.add(item);
    }
    return queue;

}
 

import android.media.MediaMetadata; //导入依赖的package包/类
/**
 * Create a random queue.
 *
 * @param musicProvider the provider used for fetching music.
 * @return list containing {@link MediaSession.QueueItem}'s
 */
public static List<MediaSession.QueueItem> getRandomQueue(MusicProvider musicProvider) {
    List<MediaMetadata> result = new ArrayList<>();

    for (String genre: musicProvider.getGenres()) {
        Iterable<MediaMetadata> tracks = musicProvider.getMusicsByGenre(genre);
        for (MediaMetadata track: tracks) {
            if (ThreadLocalRandom.current().nextBoolean()) {
                result.add(track);
            }
        }
    }
    LogHelper.d(TAG, "getRandomQueue: result.size=", result.size());

    Collections.shuffle(result);

    return convertToQueue(result, MEDIA_ID_MUSICS_BY_SEARCH, "random");
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
public synchronized void updateMusic(String musicId, MediaMetadata metadata) {
    MutableMediaMetadata track = mMusicListById.get(musicId);
    if (track == null) {
        return;
    }

    String oldGenre = track.metadata.getString(MediaMetadata.METADATA_KEY_GENRE);
    String newGenre = metadata.getString(MediaMetadata.METADATA_KEY_GENRE);

    track.metadata = metadata;

    // if genre has changed, we need to rebuild the list by genre
    if (!oldGenre.equals(newGenre)) {
        buildListsByGenre();
    }
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
private void addPlaybackControlsRow(MediaMetadata metadata) {

        mPlaybackControlsRow = new PlaybackControlsRow(new MutableMediaMetadataHolder(metadata));
        mRowsAdapter.add(mPlaybackControlsRow);

        resetPlaybackRow();

        ControlButtonPresenterSelector presenterSelector = new ControlButtonPresenterSelector();
        mPrimaryActionsAdapter = new ArrayObjectAdapter(presenterSelector);
        mPlaybackControlsRow.setPrimaryActionsAdapter(mPrimaryActionsAdapter);

        mPlayPauseAction = new PlayPauseAction(getActivity());
        mSkipNextAction = new PlaybackControlsRow.SkipNextAction(getActivity());
        mSkipPreviousAction = new PlaybackControlsRow.SkipPreviousAction(getActivity());

        mPrimaryActionsAdapter.add(mSkipPreviousAction);
        mPrimaryActionsAdapter.add(mPlayPauseAction);
        mPrimaryActionsAdapter.add(mSkipNextAction);
    }
 

import android.media.MediaMetadata; //导入依赖的package包/类
private void connectToSession(MediaSession.Token token) {
    MediaController mediaController = new MediaController(FullScreenPlayerActivity.this, token);
    if (mediaController.getMetadata() == null) {
        finish();
        return;
    }
    setMediaController(mediaController);
    mediaController.registerCallback(mCallback);
    PlaybackState state = mediaController.getPlaybackState();
    updatePlaybackState(state);
    MediaMetadata metadata = mediaController.getMetadata();
    if (metadata != null) {
        updateMediaDescription(metadata.getDescription());
        updateDuration(metadata);
    }
    updateProgress();
    if (state != null && (state.getState() == PlaybackState.STATE_PLAYING ||
            state.getState() == PlaybackState.STATE_BUFFERING)) {
        scheduleSeekbarUpdate();
    }
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
public static void updateMediaSession(boolean updateMetadata,
                                      MediaMetadata.Builder mediaBuilder,
                                      final MediaSession mediaSession,
                                      final int playbackState,
                                      final long position,
                                      final float speed) {

    if (mediaSession.isActive()) {

        if (updateMetadata) {
            mediaSession.setMetadata(mediaBuilder.build());
        }
        PlaybackState.Builder stateBuilder = new PlaybackState.Builder();
        stateBuilder.setState(playbackState,
                position,
                speed);
        mediaSession.setPlaybackState(stateBuilder.build());
    }
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
public static MediaMetadata getMetadata(Context ctx, String mediaId) {
    MediaMetadata metadataWithoutBitmap = music.get(mediaId);
    Bitmap albumArt = getAlbumBitmap(ctx, mediaId);

    // Since MediaMetadata is immutable, we need to create a copy to set the album art
    // We don't set it initially on all items so that they don't take unnecessary memory
    MediaMetadata.Builder builder = new MediaMetadata.Builder();
    for (String key: new String[]{MediaMetadata.METADATA_KEY_MEDIA_ID,
            MediaMetadata.METADATA_KEY_ALBUM, MediaMetadata.METADATA_KEY_ARTIST,
            MediaMetadata.METADATA_KEY_GENRE, MediaMetadata.METADATA_KEY_TITLE}) {
        builder.putString(key, metadataWithoutBitmap.getString(key));
    }
    builder.putLong(MediaMetadata.METADATA_KEY_DURATION,
            metadataWithoutBitmap.getLong(MediaMetadata.METADATA_KEY_DURATION));
    builder.putBitmap(MediaMetadata.METADATA_KEY_ALBUM_ART, albumArt);
    return builder.build();
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
private static void createMediaMetadata(String mediaId, String title, String artist,
            String album, String genre, long duration, int musicResId, int albumArtResId,
            String albumArtResName) {
    music.put(mediaId,
            new MediaMetadata.Builder()
            .putString(MediaMetadata.METADATA_KEY_MEDIA_ID, mediaId)
            .putString(MediaMetadata.METADATA_KEY_ALBUM, album)
            .putString(MediaMetadata.METADATA_KEY_ARTIST, artist)
            .putLong(MediaMetadata.METADATA_KEY_DURATION, duration * 1000)
            .putString(MediaMetadata.METADATA_KEY_GENRE, genre)
            .putString(MediaMetadata.METADATA_KEY_ALBUM_ART_URI, getAlbumArtUri(albumArtResName))
            .putString(MediaMetadata.METADATA_KEY_DISPLAY_ICON_URI, getAlbumArtUri(albumArtResName))
            .putString(MediaMetadata.METADATA_KEY_TITLE, title)
            .build());
    albumRes.put(mediaId, albumArtResId);
    musicRes.put(mediaId, musicResId);
}
 

import android.media.MediaMetadata; //导入依赖的package包/类
@Override
public void onCustomAction(String action, Bundle extras) {
    if (CUSTOM_ACTION_THUMBS_UP.equals(action)) {
        LogHelper.i(TAG, "onCustomAction: favorite for current track");
        MediaMetadata track = getCurrentPlayingMusic();
        if (track != null) {
            String musicId = track.getString(MediaMetadata.METADATA_KEY_MEDIA_ID);
            mMusicProvider.setFavorite(musicId, !mMusicProvider.isFavorite(musicId));
        }
        // playback state needs to be updated because the "Favorite" icon on the
        // custom action will change to reflect the new favorite state.
        updatePlaybackState(null);
    } else {
        LogHelper.e(TAG, "Unsupported action: ", action);
    }

}