src/com/android/tv/MediaSessionWrapper.java - platform/packages/apps/TV - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.tv;

 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.media.MediaMetadata;
 import android.media.session.MediaController;
 import android.media.session.MediaSession;
 import android.media.session.PlaybackState;
 import android.media.tv.TvContract;
 import android.media.tv.TvInputInfo;
 import android.os.AsyncTask;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.annotation.VisibleForTesting;
 import android.text.TextUtils;
 import android.util.Log;

 import com.android.tv.data.api.Channel;
 import com.android.tv.data.api.Program;
 import com.android.tv.util.Utils;
 import com.android.tv.util.images.ImageLoader;

 /**
  * A wrapper class for {@link MediaSession} to support common operations on media sessions for
  * {@link MainActivity}.
  */
 class MediaSessionWrapper {
     private static final String TAG = "MediaSessionWrapper";
     private static final boolean DEBUG = false;
     private static final String MEDIA_SESSION_TAG = "com.android.tv.mediasession";

     @VisibleForTesting
     static final PlaybackState MEDIA_SESSION_STATE_PLAYING =
             new PlaybackState.Builder()
                     .setState(
                             PlaybackState.STATE_PLAYING,
                             PlaybackState.PLAYBACK_POSITION_UNKNOWN,
                             1.0f)
                     .build();

     @VisibleForTesting
     static final PlaybackState MEDIA_SESSION_STATE_STOPPED =
             new PlaybackState.Builder()
                     .setState(
                             PlaybackState.STATE_STOPPED,
                             PlaybackState.PLAYBACK_POSITION_UNKNOWN,
                             0.0f)
                     .build();

     private final Context mContext;
     private final MediaSession mMediaSession;
     private final MediaController.Callback mMediaControllerCallback =
             new MediaController.Callback() {
                 @Override
                 public void onPlaybackStateChanged(@Nullable PlaybackState state) {
                     super.onPlaybackStateChanged(state);
                     if (DEBUG) {
                         Log.d(TAG, "onPlaybackStateChanged: " + state);
                     }
                     if (isMediaSessionStateStop(state)) {
                         mMediaSession.setActive(false);
                     }
                 }
             };
     private MediaController mMediaController;
     private int mNowPlayingCardWidth;
     private int mNowPlayingCardHeight;

     MediaSessionWrapper(Context context, PendingIntent pendingIntent) {
         mContext = context;
         mMediaSession = new MediaSession(context, MEDIA_SESSION_TAG);
         mMediaSession.setCallback(
                 new MediaSession.Callback() {
                     @Override
                     public boolean onMediaButtonEvent(@NonNull Intent mediaButtonIntent) {
                         // Consume the media button event here. Should not send it to other apps.
                         return true;
                     }
                 });
         mMediaSession.setFlags(
                 MediaSession.FLAG_HANDLES_MEDIA_BUTTONS
                         | MediaSession.FLAG_HANDLES_TRANSPORT_CONTROLS);
         mMediaSession.setSessionActivity(pendingIntent);

         initMediaController();
         mNowPlayingCardWidth =
                 mContext.getResources().getDimensionPixelSize(R.dimen.notif_card_img_max_width);
         mNowPlayingCardHeight =
                 mContext.getResources().getDimensionPixelSize(R.dimen.notif_card_img_height);
     }

     /**
      * Sets playback state.
      *
      * @param isPlaying {@code true} if TV is playing, otherwise {@code false}.
      */
     void setPlaybackState(boolean isPlaying) {
         if (isPlaying) {
             mMediaSession.setActive(true);
             // setPlaybackState() has to be called after calling setActive(). b/31933276
             mMediaSession.setPlaybackState(MEDIA_SESSION_STATE_PLAYING);
         } else if (mMediaSession.isActive()) {
             mMediaSession.setPlaybackState(MEDIA_SESSION_STATE_STOPPED);
         }
     }

     /**
      * Updates media session according to the current TV playback status.
      *
      * @param blocked {@code true} if the current channel is blocked, either by user settings or the
      *     current program's content ratings.
      * @param currentChannel The currently playing channel.
      * @param currentProgram The currently playing program.
      */
     void update(boolean blocked, Channel currentChannel, Program currentProgram) {
         if (currentChannel == null) {
             setPlaybackState(false);
             return;
         }

         // If the channel is blocked, display a lock and a short text on the Now Playing Card
         if (blocked) {
             Bitmap art =
                     BitmapFactory.decodeResource(
                             mContext.getResources(), R.drawable.ic_message_lock_preview);
             updateMediaMetadata(
                     mContext.getResources().getString(R.string.channel_banner_locked_channel_title),
                     art);
             setPlaybackState(true);
             return;
         }

         String cardTitleText = null;
         String posterArtUri = null;
         if (currentProgram != null) {
             cardTitleText = currentProgram.getTitle();
             posterArtUri = currentProgram.getPosterArtUri();
         }
         if (TextUtils.isEmpty(cardTitleText)) {
             cardTitleText = getChannelName(currentChannel);
         }
         updateMediaMetadata(cardTitleText, null);
         if (posterArtUri == null) {
             posterArtUri = TvContract.buildChannelLogoUri(currentChannel.getId()).toString();
         }
         updatePosterArt(currentChannel, currentProgram, cardTitleText, null, posterArtUri);
         setPlaybackState(true);
     }

     /**
      * Releases the media session.
      *
      * @see MediaSession#release()
      */
     void release() {
         unregisterMediaControllerCallback();
         mMediaSession.release();
     }

     private String getChannelName(Channel channel) {
         if (channel.isPassthrough()) {
             TvInputInfo input =
                     TvSingletons.getSingletons(mContext)
                             .getTvInputManagerHelper()
                             .getTvInputInfo(channel.getInputId());
             return Utils.loadLabel(mContext, input);
         } else {
             return channel.getDisplayName();
         }
     }

     private void updatePosterArt(
             Channel currentChannel,
             Program currentProgram,
             String cardTitleText,
             @Nullable Bitmap posterArt,
             @Nullable String posterArtUri) {
         if (posterArt != null) {
             updateMediaMetadata(cardTitleText, posterArt);
         } else if (posterArtUri != null) {
             ImageLoader.loadBitmap(
                     mContext,
                     posterArtUri,
                     mNowPlayingCardWidth,
                     mNowPlayingCardHeight,
                     new ProgramPosterArtCallback(
                             this, currentChannel, currentProgram, cardTitleText));
         } else {
             updateMediaMetadata(cardTitleText, R.drawable.default_now_card);
         }
     }

     private void updateMediaMetadata(final String title, final Bitmap posterArt) {
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... arg0) {
                 MediaMetadata.Builder builder = new MediaMetadata.Builder();
                 builder.putString(MediaMetadata.METADATA_KEY_TITLE, title);
                 if (posterArt != null) {
                     builder.putBitmap(MediaMetadata.METADATA_KEY_ART, posterArt);
                 }
                 mMediaSession.setMetadata(builder.build());
                 return null;
             }
         }.execute();
     }

     private void updateMediaMetadata(final String title, final int imageResId) {
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... arg0) {
                 MediaMetadata.Builder builder = new MediaMetadata.Builder();
                 builder.putString(MediaMetadata.METADATA_KEY_TITLE, title);
                 Bitmap posterArt =
                         BitmapFactory.decodeResource(mContext.getResources(), imageResId);
                 if (posterArt != null) {
                     builder.putBitmap(MediaMetadata.METADATA_KEY_ART, posterArt);
                 }
                 mMediaSession.setMetadata(builder.build());
                 return null;
             }
         }.execute();
     }

     @VisibleForTesting
     MediaSession getMediaSession() {
         return mMediaSession;
     }

     @VisibleForTesting
     MediaController.Callback getMediaControllerCallback() {
         return mMediaControllerCallback;
     }

     @VisibleForTesting
     void initMediaController() {
         mMediaController = new MediaController(mContext, mMediaSession.getSessionToken());
         ((Activity) mContext).setMediaController(mMediaController);
         mMediaController.registerCallback(mMediaControllerCallback);
     }

     @VisibleForTesting
     void unregisterMediaControllerCallback() {
         mMediaController.unregisterCallback(mMediaControllerCallback);
     }

     private static boolean isMediaSessionStateStop(PlaybackState state) {
         return state != null
                 && state.getState() == MEDIA_SESSION_STATE_STOPPED.getState()
                 && state.getPosition() == MEDIA_SESSION_STATE_STOPPED.getPosition()
                 && state.getPlaybackSpeed() == MEDIA_SESSION_STATE_STOPPED.getPlaybackSpeed();
     }

     private static class ProgramPosterArtCallback
             extends ImageLoader.ImageLoaderCallback<MediaSessionWrapper> {
         private final Channel mChannel;
         private final Program mProgram;
         private final String mCardTitleText;

         ProgramPosterArtCallback(
                 MediaSessionWrapper sessionWrapper,
                 Channel channel,
                 Program program,
                 String cardTitleText) {
             super(sessionWrapper);
             mChannel = channel;
             mProgram = program;
             mCardTitleText = cardTitleText;
         }

         @Override
         public void onBitmapLoaded(MediaSessionWrapper sessionWrapper, @Nullable Bitmap posterArt) {
             if (((MainActivity) sessionWrapper.mContext).isNowPlayingProgram(mChannel, mProgram)) {
                 sessionWrapper.updatePosterArt(mChannel, mProgram, mCardTitleText, posterArt, null);
             }
         }
     }
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.tv;

	import android.app.Activity;
	import android.app.PendingIntent;
	import android.content.Context;
	import android.content.Intent;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.media.MediaMetadata;
	import android.media.session.MediaController;
	import android.media.session.MediaSession;
	import android.media.session.PlaybackState;
	import android.media.tv.TvContract;
	import android.media.tv.TvInputInfo;
	import android.os.AsyncTask;
	import android.support.annotation.NonNull;
	import android.support.annotation.Nullable;
	import android.support.annotation.VisibleForTesting;
	import android.text.TextUtils;
	import android.util.Log;

	import com.android.tv.data.api.Channel;
	import com.android.tv.data.api.Program;
	import com.android.tv.util.Utils;
	import com.android.tv.util.images.ImageLoader;

	/**
	* A wrapper class for {@link MediaSession} to support common operations on media sessions for
	* {@link MainActivity}.
	*/
	class MediaSessionWrapper {
	private static final String TAG = "MediaSessionWrapper";
	private static final boolean DEBUG = false;
	private static final String MEDIA_SESSION_TAG = "com.android.tv.mediasession";

	@VisibleForTesting
	static final PlaybackState MEDIA_SESSION_STATE_PLAYING =
	new PlaybackState.Builder()
	.setState(
	PlaybackState.STATE_PLAYING,
	PlaybackState.PLAYBACK_POSITION_UNKNOWN,
	1.0f)
	.build();

	@VisibleForTesting
	static final PlaybackState MEDIA_SESSION_STATE_STOPPED =
	new PlaybackState.Builder()
	.setState(
	PlaybackState.STATE_STOPPED,
	PlaybackState.PLAYBACK_POSITION_UNKNOWN,
	0.0f)
	.build();

	private final Context mContext;
	private final MediaSession mMediaSession;
	private final MediaController.Callback mMediaControllerCallback =
	new MediaController.Callback() {
	@Override
	public void onPlaybackStateChanged(@Nullable PlaybackState state) {
	super.onPlaybackStateChanged(state);
	if (DEBUG) {
	Log.d(TAG, "onPlaybackStateChanged: " + state);
	}
	if (isMediaSessionStateStop(state)) {
	mMediaSession.setActive(false);
	}
	}
	};
	private MediaController mMediaController;
	private int mNowPlayingCardWidth;
	private int mNowPlayingCardHeight;

	MediaSessionWrapper(Context context, PendingIntent pendingIntent) {
	mContext = context;
	mMediaSession = new MediaSession(context, MEDIA_SESSION_TAG);
	mMediaSession.setCallback(
	new MediaSession.Callback() {
	@Override
	public boolean onMediaButtonEvent(@NonNull Intent mediaButtonIntent) {
	// Consume the media button event here. Should not send it to other apps.
	return true;
	}
	});
	mMediaSession.setFlags(
	MediaSession.FLAG_HANDLES_MEDIA_BUTTONS
	\| MediaSession.FLAG_HANDLES_TRANSPORT_CONTROLS);
	mMediaSession.setSessionActivity(pendingIntent);

	initMediaController();
	mNowPlayingCardWidth =
	mContext.getResources().getDimensionPixelSize(R.dimen.notif_card_img_max_width);
	mNowPlayingCardHeight =
	mContext.getResources().getDimensionPixelSize(R.dimen.notif_card_img_height);
	}

	/**
	* Sets playback state.
	*
	* @param isPlaying {@code true} if TV is playing, otherwise {@code false}.
	*/
	void setPlaybackState(boolean isPlaying) {
	if (isPlaying) {
	mMediaSession.setActive(true);
	// setPlaybackState() has to be called after calling setActive(). b/31933276
	mMediaSession.setPlaybackState(MEDIA_SESSION_STATE_PLAYING);
	} else if (mMediaSession.isActive()) {
	mMediaSession.setPlaybackState(MEDIA_SESSION_STATE_STOPPED);
	}
	}

	/**
	* Updates media session according to the current TV playback status.
	*
	* @param blocked {@code true} if the current channel is blocked, either by user settings or the
	* current program's content ratings.
	* @param currentChannel The currently playing channel.
	* @param currentProgram The currently playing program.
	*/
	void update(boolean blocked, Channel currentChannel, Program currentProgram) {
	if (currentChannel == null) {
	setPlaybackState(false);
	return;
	}

	// If the channel is blocked, display a lock and a short text on the Now Playing Card
	if (blocked) {
	Bitmap art =
	BitmapFactory.decodeResource(
	mContext.getResources(), R.drawable.ic_message_lock_preview);
	updateMediaMetadata(
	mContext.getResources().getString(R.string.channel_banner_locked_channel_title),
	art);
	setPlaybackState(true);
	return;
	}

	String cardTitleText = null;
	String posterArtUri = null;
	if (currentProgram != null) {
	cardTitleText = currentProgram.getTitle();
	posterArtUri = currentProgram.getPosterArtUri();
	}
	if (TextUtils.isEmpty(cardTitleText)) {
	cardTitleText = getChannelName(currentChannel);
	}
	updateMediaMetadata(cardTitleText, null);
	if (posterArtUri == null) {
	posterArtUri = TvContract.buildChannelLogoUri(currentChannel.getId()).toString();
	}
	updatePosterArt(currentChannel, currentProgram, cardTitleText, null, posterArtUri);
	setPlaybackState(true);
	}

	/**
	* Releases the media session.
	*
	* @see MediaSession#release()
	*/
	void release() {
	unregisterMediaControllerCallback();
	mMediaSession.release();
	}

	private String getChannelName(Channel channel) {
	if (channel.isPassthrough()) {
	TvInputInfo input =
	TvSingletons.getSingletons(mContext)
	.getTvInputManagerHelper()
	.getTvInputInfo(channel.getInputId());
	return Utils.loadLabel(mContext, input);
	} else {
	return channel.getDisplayName();
	}
	}

	private void updatePosterArt(
	Channel currentChannel,
	Program currentProgram,
	String cardTitleText,
	@Nullable Bitmap posterArt,
	@Nullable String posterArtUri) {
	if (posterArt != null) {
	updateMediaMetadata(cardTitleText, posterArt);
	} else if (posterArtUri != null) {
	ImageLoader.loadBitmap(
	mContext,
	posterArtUri,
	mNowPlayingCardWidth,
	mNowPlayingCardHeight,
	new ProgramPosterArtCallback(
	this, currentChannel, currentProgram, cardTitleText));
	} else {
	updateMediaMetadata(cardTitleText, R.drawable.default_now_card);
	}
	}

	private void updateMediaMetadata(final String title, final Bitmap posterArt) {
	new AsyncTask<Void, Void, Void>() {
	@Override
	protected Void doInBackground(Void... arg0) {
	MediaMetadata.Builder builder = new MediaMetadata.Builder();
	builder.putString(MediaMetadata.METADATA_KEY_TITLE, title);
	if (posterArt != null) {
	builder.putBitmap(MediaMetadata.METADATA_KEY_ART, posterArt);
	}
	mMediaSession.setMetadata(builder.build());
	return null;
	}
	}.execute();
	}

	private void updateMediaMetadata(final String title, final int imageResId) {
	new AsyncTask<Void, Void, Void>() {
	@Override
	protected Void doInBackground(Void... arg0) {
	MediaMetadata.Builder builder = new MediaMetadata.Builder();
	builder.putString(MediaMetadata.METADATA_KEY_TITLE, title);
	Bitmap posterArt =
	BitmapFactory.decodeResource(mContext.getResources(), imageResId);
	if (posterArt != null) {
	builder.putBitmap(MediaMetadata.METADATA_KEY_ART, posterArt);
	}
	mMediaSession.setMetadata(builder.build());
	return null;
	}
	}.execute();
	}

	@VisibleForTesting
	MediaSession getMediaSession() {
	return mMediaSession;
	}

	@VisibleForTesting
	MediaController.Callback getMediaControllerCallback() {
	return mMediaControllerCallback;
	}

	@VisibleForTesting
	void initMediaController() {
	mMediaController = new MediaController(mContext, mMediaSession.getSessionToken());
	((Activity) mContext).setMediaController(mMediaController);
	mMediaController.registerCallback(mMediaControllerCallback);
	}

	@VisibleForTesting
	void unregisterMediaControllerCallback() {
	mMediaController.unregisterCallback(mMediaControllerCallback);
	}

	private static boolean isMediaSessionStateStop(PlaybackState state) {
	return state != null
	&& state.getState() == MEDIA_SESSION_STATE_STOPPED.getState()
	&& state.getPosition() == MEDIA_SESSION_STATE_STOPPED.getPosition()
	&& state.getPlaybackSpeed() == MEDIA_SESSION_STATE_STOPPED.getPlaybackSpeed();
	}

	private static class ProgramPosterArtCallback
	extends ImageLoader.ImageLoaderCallback<MediaSessionWrapper> {
	private final Channel mChannel;
	private final Program mProgram;
	private final String mCardTitleText;

	ProgramPosterArtCallback(
	MediaSessionWrapper sessionWrapper,
	Channel channel,
	Program program,
	String cardTitleText) {
	super(sessionWrapper);
	mChannel = channel;
	mProgram = program;
	mCardTitleText = cardTitleText;
	}

	@Override
	public void onBitmapLoaded(MediaSessionWrapper sessionWrapper, @Nullable Bitmap posterArt) {
	if (((MainActivity) sessionWrapper.mContext).isNowPlayingProgram(mChannel, mProgram)) {
	sessionWrapper.updatePosterArt(mChannel, mProgram, mCardTitleText, posterArt, null);
	}
	}
	}
	}