package com.markzhai.lyrichere;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.os.RemoteException;
import android.support.v4.media.MediaDescriptionCompat;
import android.support.v4.media.MediaMetadataCompat;
import android.support.v4.media.session.MediaControllerCompat;
import android.support.v4.media.session.MediaSessionCompat;
import android.support.v4.media.session.PlaybackStateCompat;
import android.support.v7.app.NotificationCompat;
import com.markzhai.lyrichere.ui.MusicPlayerActivity;
import com.markzhai.lyrichere.utils.LogUtils;
import com.markzhai.lyrichere.utils.ResourceHelper;
/**
* Keeps track of a notification and updates it automatically for a given
* MediaSession. Maintaining a visible notification (usually) guarantees that the music service
* won't be killed during playback.
*/
public class MediaNotificationManager extends BroadcastReceiver {
private static final String TAG = LogUtils.makeLogTag(MediaNotificationManager.class);
private static final int NOTIFICATION_ID = 412;
private static final int REQUEST_CODE = 100;
public static final String ACTION_PAUSE = "com.markzhai.lyrichere.pause";
public static final String ACTION_PLAY = "com.markzhai.lyrichere.play";
public static final String ACTION_PREV = "com.markzhai.lyrichere.prev";
public static final String ACTION_NEXT = "com.markzhai.lyrichere.next";
public static final String ACTION_STOP_CASTING = "com.markzhai.lyrichere.stop_cast";
private final MusicService mService;
private MediaSessionCompat.Token mSessionToken;
private MediaControllerCompat mController;
private MediaControllerCompat.TransportControls mTransportControls;
private PlaybackStateCompat mPlaybackState;
private MediaMetadataCompat mMetadata;
private final NotificationManager mNotificationManager;
private final PendingIntent mPauseIntent;
private final PendingIntent mPlayIntent;
private final PendingIntent mPreviousIntent;
private final PendingIntent mNextIntent;
private final PendingIntent mStopCastIntent;
private int mNotificationColor;
private boolean mStarted = false;
public MediaNotificationManager(MusicService service) {
mService = service;
updateSessionToken();
try {
mNotificationColor = ResourceHelper.getThemeColor(mService,
android.R.attr.colorPrimary, Color.DKGRAY);
} catch (Exception e) {
mNotificationColor = Color.DKGRAY;
}
mNotificationManager = (NotificationManager) mService
.getSystemService(Context.NOTIFICATION_SERVICE);
String pkg = mService.getPackageName();
mPauseIntent = PendingIntent.getBroadcast(mService, REQUEST_CODE,
new Intent(ACTION_PAUSE).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mPlayIntent = PendingIntent.getBroadcast(mService, REQUEST_CODE,
new Intent(ACTION_PLAY).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mPreviousIntent = PendingIntent.getBroadcast(mService, REQUEST_CODE,
new Intent(ACTION_PREV).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mNextIntent = PendingIntent.getBroadcast(mService, REQUEST_CODE,
new Intent(ACTION_NEXT).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mStopCastIntent = PendingIntent.getBroadcast(mService, REQUEST_CODE,
new Intent(ACTION_STOP_CASTING).setPackage(pkg),
PendingIntent.FLAG_CANCEL_CURRENT);
// Cancel all notifications to handle the case where the Service was killed and
// restarted by the system.
mNotificationManager.cancelAll();
}
/**
* Posts the notification and starts tracking the session to keep it
* updated. The notification will automatically be removed if the session is
* destroyed before {@link #stopNotification} is called.
*/
public void startNotification() {
if (!mStarted) {
mMetadata = mController.getMetadata();
mPlaybackState = mController.getPlaybackState();
// The notification must be updated after setting started to true
Notification notification = createNotification();
if (notification != null) {
mController.registerCallback(mCb);
IntentFilter filter = new IntentFilter();
filter.addAction(ACTION_NEXT);
filter.addAction(ACTION_PAUSE);
filter.addAction(ACTION_PLAY);
filter.addAction(ACTION_PREV);
filter.addAction(ACTION_STOP_CASTING);
mService.registerReceiver(this, filter);
mService.startForeground(NOTIFICATION_ID, notification);
mStarted = true;
}
}
}
/**
* Removes the notification and stops tracking the session. If the session
* was destroyed this has no effect.
*/
public void stopNotification() {
if (mStarted) {
mStarted = false;
mController.unregisterCallback(mCb);
try {
mNotificationManager.cancel(NOTIFICATION_ID);
mService.unregisterReceiver(this);
} catch (IllegalArgumentException ex) {
// ignore if the receiver is not registered.
}
mService.stopForeground(true);
}
}
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
LogUtils.d(TAG, "Received intent with action " + action);
switch (action) {
case ACTION_PAUSE:
mTransportControls.pause();
break;
case ACTION_PLAY:
mTransportControls.play();
break;
case ACTION_NEXT:
mTransportControls.skipToNext();
break;
case ACTION_PREV:
mTransportControls.skipToPrevious();
break;
case ACTION_STOP_CASTING:
Intent i = new Intent(context, MusicService.class);
i.setAction(MusicService.ACTION_CMD);
i.putExtra(MusicService.CMD_NAME, MusicService.CMD_STOP_CASTING);
mService.startService(i);
break;
default:
LogUtils.w(TAG, "Unknown intent ignored. Action=", action);
}
}
/**
* Update the state based on a change on the session token. Called either when
* we are running for the first time or when the media session owner has destroyed the session
* (see {@link android.media.session.MediaController.Callback#onSessionDestroyed()})
*/
private void updateSessionToken() {
try {
MediaSessionCompat.Token freshToken = mService.getSessionToken();
if (mSessionToken == null || !mSessionToken.equals(freshToken)) {
if (mController != null) {
mController.unregisterCallback(mCb);
}
mSessionToken = freshToken;
mController = new MediaControllerCompat(mService, mSessionToken);
mTransportControls = mController.getTransportControls();
if (mStarted) {
mController.registerCallback(mCb);
}
}
} catch (RemoteException ex) {
}
}
private PendingIntent createContentIntent(MediaDescriptionCompat description) {
Intent openUI = new Intent(mService, MusicPlayerActivity.class);
openUI.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
openUI.putExtra(MusicPlayerActivity.EXTRA_START_FULLSCREEN, true);
if (description != null) {
openUI.putExtra(MusicPlayerActivity.EXTRA_CURRENT_MEDIA_DESCRIPTION, description);
}
return PendingIntent.getActivity(mService, REQUEST_CODE, openUI,
PendingIntent.FLAG_CANCEL_CURRENT);
}
private final MediaControllerCompat.Callback mCb = new MediaControllerCompat.Callback() {
@Override
public void onPlaybackStateChanged(PlaybackStateCompat state) {
mPlaybackState = state;
LogUtils.d(TAG, "Received new playback state", state);
if (state != null && (state.getState() == PlaybackStateCompat.STATE_STOPPED ||
state.getState() == PlaybackStateCompat.STATE_NONE)) {
stopNotification();
} else {
Notification notification = createNotification();
if (notification != null) {
mNotificationManager.notify(NOTIFICATION_ID, notification);
}
}
}
@Override
public void onMetadataChanged(MediaMetadataCompat metadata) {
mMetadata = metadata;
LogUtils.d(TAG, "Received new metadata ", metadata);
Notification notification = createNotification();
if (notification != null) {
mNotificationManager.notify(NOTIFICATION_ID, notification);
}
}
@Override
public void onSessionDestroyed() {
super.onSessionDestroyed();
LogUtils.d(TAG, "Session was destroyed, resetting to the new session token");
updateSessionToken();
}
};
private Notification createNotification() {
LogUtils.d(TAG, "updateNotificationMetadata. mMetadata=" + mMetadata);
if (mMetadata == null || mPlaybackState == null) {
return null;
}
NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(mService);
int playPauseButtonPosition = 0;
// If skip to previous action is enabled
if ((mPlaybackState.getActions() & PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS) != 0) {
notificationBuilder.addAction(R.drawable.ic_skip_previous_white_24dp,
mService.getString(R.string.label_previous), mPreviousIntent);
// If there is a "skip to previous" button, the play/pause button will
// be the second one. We need to keep track of it, because the MediaStyle notification
// requires to specify the index of the buttons (actions) that should be visible
// when in compact view.
playPauseButtonPosition = 1;
}
addPlayPauseAction(notificationBuilder);
// If skip to next action is enabled
if ((mPlaybackState.getActions() & PlaybackStateCompat.ACTION_SKIP_TO_NEXT) != 0) {
notificationBuilder.addAction(R.drawable.ic_skip_next_white_24dp,
mService.getString(R.string.label_next), mNextIntent);
}
MediaDescriptionCompat description = mMetadata.getDescription();
String fetchArtUrl = null;
Bitmap art = null;
if (description.getIconUri() != null) {
// This sample assumes the iconUri will be a valid URL formatted String, but
// it can actually be any valid Android Uri formatted String.
// async fetch the album art icon
String artUrl = description.getIconUri().toString();
art = AlbumArtCache.getInstance().getBigImage(artUrl);
if (art == null || art.isRecycled()) {
fetchArtUrl = artUrl;
// use a placeholder art while the remote art is being downloaded
art = BitmapFactory.decodeResource(mService.getResources(), R.drawable.ic_default_art);
}
}
notificationBuilder
.setStyle(new NotificationCompat.MediaStyle()
.setShowActionsInCompactView(
new int[]{playPauseButtonPosition}) // show only play/pause in compact view
.setMediaSession(mSessionToken))
.setColor(mNotificationColor)
.setSmallIcon(R.drawable.ic_notification)
.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
.setUsesChronometer(true)
.setContentIntent(createContentIntent(description))
.setContentTitle(description.getTitle())
.setContentText(description.getSubtitle())
.setLargeIcon(art);
if (mController != null && mController.getExtras() != null) {
String castName = mController.getExtras().getString(MusicService.EXTRA_CONNECTED_CAST);
if (castName != null) {
String castInfo = mService.getResources()
.getString(R.string.casting_to_device, castName);
notificationBuilder.setSubText(castInfo);
notificationBuilder.addAction(R.drawable.ic_close_black_24dp,
mService.getString(R.string.stop_casting), mStopCastIntent);
}
}
setNotificationPlaybackState(notificationBuilder);
if (fetchArtUrl != null) {
fetchBitmapFromURLAsync(fetchArtUrl, notificationBuilder);
}
return notificationBuilder.build();
}
private void addPlayPauseAction(NotificationCompat.Builder builder) {
LogUtils.d(TAG, "updatePlayPauseAction");
String label;
int icon;
PendingIntent intent;
if (mPlaybackState.getState() == PlaybackStateCompat.STATE_PLAYING) {
label = mService.getString(R.string.label_pause);
icon = R.drawable.ic_pause_white_24dp;
intent = mPauseIntent;
} else {
label = mService.getString(R.string.label_play);
icon = R.drawable.ic_play_arrow_white_24dp;
intent = mPlayIntent;
}
builder.addAction(new NotificationCompat.Action(icon, label, intent));
}
private void setNotificationPlaybackState(NotificationCompat.Builder builder) {
LogUtils.d(TAG, "updateNotificationPlaybackState. mPlaybackState=" + mPlaybackState);
if (mPlaybackState == null || !mStarted) {
LogUtils.d(TAG, "updateNotificationPlaybackState. cancelling notification!");
mService.stopForeground(true);
return;
}
if (mPlaybackState.getState() == PlaybackStateCompat.STATE_PLAYING
&& mPlaybackState.getPosition() >= 0) {
LogUtils.d(TAG, "updateNotificationPlaybackState. updating playback position to ",
(System.currentTimeMillis() - mPlaybackState.getPosition()) / 1000, " seconds");
builder
.setWhen(System.currentTimeMillis() - mPlaybackState.getPosition())
.setShowWhen(true)
.setUsesChronometer(true);
} else {
LogUtils.d(TAG, "updateNotificationPlaybackState. hiding playback position");
builder
.setWhen(0)
.setShowWhen(false)
.setUsesChronometer(false);
}
// Make sure that the notification can be dismissed by the user when we are not playing:
builder.setOngoing(mPlaybackState.getState() == PlaybackStateCompat.STATE_PLAYING);
}
private void fetchBitmapFromURLAsync(final String bitmapUrl,
final NotificationCompat.Builder builder) {
AlbumArtCache.getInstance().fetch(bitmapUrl, new AlbumArtCache.FetchListener() {
@Override
public void onFetched(String artUrl, Bitmap bitmap, Bitmap icon) {
if (mMetadata != null && mMetadata.getDescription() != null &&
artUrl.equals(mMetadata.getDescription().getIconUri().toString())) {
// If the media is still the same, update the notification:
LogUtils.d(TAG, "fetchBitmapFromURLAsync: set bitmap to ", artUrl);
if (bitmap != null && !bitmap.isRecycled()) {
builder.setLargeIcon(bitmap);
}
mNotificationManager.notify(NOTIFICATION_ID, builder.build());
}
}
});
}
}
