src/com/android/car/stream/media/MediaPlaybackMonitor.java - platform/packages/apps/Car/Stream - Git at Google

 /*
  * Copyright (c) 2016, 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.car.stream.media;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.media.MediaDescription;
 import android.media.MediaMetadata;
 import android.media.session.PlaybackState;
 import android.net.Uri;
 import android.os.Handler;
 import android.os.Message;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.text.TextUtils;
 import android.util.Log;
 import com.android.car.apps.common.BitmapDownloader;
 import com.android.car.apps.common.BitmapWorkerOptions;
 import com.android.car.stream.R;

 /**
  * An service which connects to {@link MediaStateManager} for media updates (playback state and
  * metadata) and notifies listeners for these changes.
  * <p/>
  */
 public class MediaPlaybackMonitor implements MediaStateManager.Listener {
     protected static final String TAG = "MediaPlaybackMonitor";

     // MSG for metadata update handler
     private static final int MSG_UPDATE_METADATA = 1;
     private static final int MSG_IMAGE_DOWNLOADED = 2;
     private static final int MSG_NEW_ALBUM_ART_RECEIVED = 3;

     public interface MediaPlaybackMonitorListener {
         void onPlaybackStateChanged(PlaybackState state);

         void onMetadataChanged(String title, String text, Bitmap art, int color, String appName);

         void onAlbumArtUpdated(Bitmap albumArt);

         void onNewAppConnected();

         void removeMediaStreamCard();
     }

     private static final String[] PREFERRED_BITMAP_ORDER = {
             MediaMetadata.METADATA_KEY_ALBUM_ART,
             MediaMetadata.METADATA_KEY_ART,
             MediaMetadata.METADATA_KEY_DISPLAY_ICON
     };

     private static final String[] PREFERRED_URI_ORDER = {
             MediaMetadata.METADATA_KEY_ALBUM_ART_URI,
             MediaMetadata.METADATA_KEY_ART_URI,
             MediaMetadata.METADATA_KEY_DISPLAY_ICON_URI
     };

     private MediaMetadata mCurrentMetadata;
     private MediaStatusUpdateHandler mMediaStatusUpdateHandler;
     private MediaAppInfo mCurrentMediaAppInfo;
     private MediaPlaybackMonitorListener mMonitorListener;

     private Context mContext;

     private final int mIconSize;

     public MediaPlaybackMonitor(Context context, @NonNull MediaPlaybackMonitorListener callback) {
         mContext = context;
         mMonitorListener = callback;
         mIconSize = mContext.getResources().getDimensionPixelSize(R.dimen.stream_media_icon_size);
     }

     public final void start() {
         mMediaStatusUpdateHandler = new MediaStatusUpdateHandler();
     }

     public final void stop() {
         if (mMediaStatusUpdateHandler != null) {
             mMediaStatusUpdateHandler.removeCallbacksAndMessages(null);
             mMediaStatusUpdateHandler = null;
         }
     }

     @Override
     public void onMediaSessionConnected(PlaybackState state, MediaMetadata metaData,
             MediaAppInfo appInfo) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "MediaSession onConnected called");
         }

         // If the current media app is not the same as the new media app, reset
         // the media app in MediaStreamManager
         if (mCurrentMediaAppInfo == null
                 || !mCurrentMediaAppInfo.getPackageName().equals(appInfo.getPackageName())) {
             mMonitorListener.onNewAppConnected();
             if (mMediaStatusUpdateHandler != null) {
                 mMediaStatusUpdateHandler.removeCallbacksAndMessages(null);
             }
             mCurrentMediaAppInfo = appInfo;
         }

         if (metaData != null) {
             onMetadataChanged(metaData);
         }

         if (state != null) {
             onPlaybackStateChanged(state);
         }
     }

     @Override
     public void onPlaybackStateChanged(@Nullable PlaybackState state) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "onPlaybackStateChanged called " + state.getState());
         }

         if (state == null) {
             Log.w(TAG, "playback state is null in onPlaybackStateChanged");
             mMonitorListener.removeMediaStreamCard();
             return;
         }

         if (mMonitorListener != null) {
             mMonitorListener.onPlaybackStateChanged(state);
         }
     }

     @Override
     public void onMetadataChanged(@Nullable MediaMetadata metadata) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "onMetadataChanged called");
         }
         if (metadata == null) {
             mMonitorListener.removeMediaStreamCard();
             return;
         }
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "received " + metadata.getDescription());
         }
         // Compare the new metadata and the last we have posted notification for. If both
         // metadata and album art are the same, just ignore and return. If the album art is new,
         // update the stream item with the new album art.
         MediaDescription currentDescription = mCurrentMetadata == null ?
                 null : mCurrentMetadata.getDescription();

         if (!MediaUtils.isSameMediaDescription(metadata.getDescription(), currentDescription)) {
             Message msg =
                     mMediaStatusUpdateHandler.obtainMessage(MSG_UPDATE_METADATA, metadata);
             // Remove obsolete notifications  in the queue.
             mMediaStatusUpdateHandler.removeMessages(MSG_UPDATE_METADATA);
             mMediaStatusUpdateHandler.sendMessage(msg);
         } else {
             Bitmap newBitmap = metadata.getDescription().getIconBitmap();
             if (newBitmap == null) {
                 return;
             }
             if (newBitmap.sameAs(mMediaStatusUpdateHandler.getCurrentIcon())) {
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "Received duplicate metadata, ignoring...");
                 }
             } else {
                 // same metadata, but new album art
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "Received metadata with new album art");
                 }
                 Message msg = mMediaStatusUpdateHandler
                         .obtainMessage(MSG_NEW_ALBUM_ART_RECEIVED, newBitmap);
                 mMediaStatusUpdateHandler.removeMessages(MSG_NEW_ALBUM_ART_RECEIVED);
                 mMediaStatusUpdateHandler.sendMessage(msg);
             }
         }
     }

     @Override
     public void onSessionDestroyed() {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "Media session destroyed");
         }
         mMonitorListener.removeMediaStreamCard();
     }

     private class BitmapCallback extends BitmapDownloader.BitmapCallback {
         final private int mSeq;

         public BitmapCallback(int seq) {
             mSeq = seq;
         }

         @Override
         public void onBitmapRetrieved(Bitmap bitmap) {
             if (mMediaStatusUpdateHandler == null) {
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "The callback comes after we finish");
                 }
                 return;
             }
             Message msg = mMediaStatusUpdateHandler.obtainMessage(MSG_IMAGE_DOWNLOADED,
                     mSeq, 0, bitmap);
             mMediaStatusUpdateHandler.sendMessage(msg);
         }
     }

     private class MediaStatusUpdateHandler extends Handler {
         private int mSeq = 0;
         private BitmapCallback mCallback;
         private MediaMetadata mMetadata;
         private String mTitle;
         private String mSubtitle;
         private Bitmap mIcon;
         private Uri mIconUri;
         private final BitmapDownloader mDownloader = BitmapDownloader.getInstance(mContext);

         private void extractMetadata(MediaMetadata metadata) {
             if (metadata == mMetadata) {
                 // We are up to date and must return here, because we've already recycled the bitmap
                 // inside it.
                 return;
             }
             // keep a reference so we know which metadata we have stored.
             mMetadata = metadata;
             MediaDescription description = metadata.getDescription();
             mTitle = description.getTitle() == null ? null : description.getTitle().toString();
             mSubtitle = description.getSubtitle() == null ?
                     null : description.getSubtitle().toString();
             final Bitmap originalBitmap = getMetadataBitmap(metadata);
             if (originalBitmap != null) {
                 mIcon = originalBitmap;
             } else {
                 mIcon = null;
             }
             mIconUri = getMetadataIconUri(metadata);
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "Album Art Uri: " + mIconUri);
             }
         }

         private Uri getMetadataIconUri(MediaMetadata metadata) {
             // Get the best Uri we can find
             for (int i = 0; i < PREFERRED_URI_ORDER.length; i++) {
                 String iconUri = metadata.getString(PREFERRED_URI_ORDER[i]);
                 if (!TextUtils.isEmpty(iconUri)) {
                     return Uri.parse(iconUri);
                 }
             }
             return null;
         }

         private Bitmap getMetadataBitmap(MediaMetadata metadata) {
             // Get the best art bitmap we can find
             for (int i = 0; i < PREFERRED_BITMAP_ORDER.length; i++) {
                 Bitmap bitmap = metadata.getBitmap(PREFERRED_BITMAP_ORDER[i]);
                 if (bitmap != null) {
                     if (Log.isLoggable(TAG, Log.DEBUG)) {
                         Log.d(TAG, "Retrieved bitmap type: " + PREFERRED_BITMAP_ORDER[i]
                                 + " w: " + bitmap.getWidth()
                                 + " h: " + bitmap.getHeight());
                     }
                     return bitmap;
                 }
             }
             return null;
         }

         public Bitmap getCurrentIcon() {
             return mIcon;
         }

         @Override
         public void handleMessage(Message msg) {
             MediaAppInfo mediaAppInfo = mCurrentMediaAppInfo;
             int color = mediaAppInfo.getMediaClientAccentColor();
             String appName = mediaAppInfo.getAppName();
             switch (msg.what) {
                 case MSG_UPDATE_METADATA:
                     mSeq++;
                     MediaMetadata metadata = (MediaMetadata) msg.obj;
                     if (metadata == null) {
                         Log.w(TAG, "media metadata is null!");
                         return;
                     }
                     extractMetadata(metadata);
                     if (mCallback != null) {
                         // it's ok to cancel a callback that has already been called, the downloader
                         // will just ignore the operation.
                         mDownloader.cancelDownload(mCallback);
                         mCallback = null;
                     }
                     if (mIcon != null) {
                         mMonitorListener.onMetadataChanged(mTitle, mSubtitle, mIcon,
                                 color, appName);
                     } else if (mIconUri != null) {
                         mCallback = new BitmapCallback(mSeq);
                         mDownloader.getBitmap(
                                 new BitmapWorkerOptions.Builder(mContext)
                                         .resource(mIconUri).width(mIconSize)
                                         .height(mIconSize).build(), mCallback);
                     } else {
                         mMonitorListener.onMetadataChanged(mTitle, mSubtitle, mIcon,
                                 color, appName);
                     }
                     // Only set mCurrentMetadata after we have updated the listener (if the
                     // bitmap is downloaded asynchronously, that is fine too. The stream card will
                     // be posted, when image is downloaded.)
                     mCurrentMetadata = metadata;
                     break;

                 case MSG_IMAGE_DOWNLOADED:
                     if (Log.isLoggable(TAG, Log.DEBUG)) {
                         Log.d(TAG, "Image downloaded...");
                     }
                     int seq = msg.arg1;
                     Bitmap bitmap = (Bitmap) msg.obj;
                     if (seq == mSeq) {
                         mMonitorListener.onMetadataChanged(mTitle, mSubtitle, bitmap, color, appName);
                     }
                     break;

                 case MSG_NEW_ALBUM_ART_RECEIVED:
                     if (Log.isLoggable(TAG, Log.DEBUG)) {
                         Log.d(TAG, "Received a new album art...");
                     }
                     Bitmap newAlbumArt = (Bitmap) msg.obj;
                     mMonitorListener.onAlbumArtUpdated(newAlbumArt);
                     break;
                 default:
             }
         }
     }
 }
	/*
	* Copyright (c) 2016, 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.car.stream.media;

	import android.content.Context;
	import android.graphics.Bitmap;
	import android.media.MediaDescription;
	import android.media.MediaMetadata;
	import android.media.session.PlaybackState;
	import android.net.Uri;
	import android.os.Handler;
	import android.os.Message;
	import android.support.annotation.NonNull;
	import android.support.annotation.Nullable;
	import android.text.TextUtils;
	import android.util.Log;
	import com.android.car.apps.common.BitmapDownloader;
	import com.android.car.apps.common.BitmapWorkerOptions;
	import com.android.car.stream.R;

	/**
	* An service which connects to {@link MediaStateManager} for media updates (playback state and
	* metadata) and notifies listeners for these changes.
	* <p/>
	*/
	public class MediaPlaybackMonitor implements MediaStateManager.Listener {
	protected static final String TAG = "MediaPlaybackMonitor";

	// MSG for metadata update handler
	private static final int MSG_UPDATE_METADATA = 1;
	private static final int MSG_IMAGE_DOWNLOADED = 2;
	private static final int MSG_NEW_ALBUM_ART_RECEIVED = 3;

	public interface MediaPlaybackMonitorListener {
	void onPlaybackStateChanged(PlaybackState state);

	void onMetadataChanged(String title, String text, Bitmap art, int color, String appName);

	void onAlbumArtUpdated(Bitmap albumArt);

	void onNewAppConnected();

	void removeMediaStreamCard();
	}

	private static final String[] PREFERRED_BITMAP_ORDER = {
	MediaMetadata.METADATA_KEY_ALBUM_ART,
	MediaMetadata.METADATA_KEY_ART,
	MediaMetadata.METADATA_KEY_DISPLAY_ICON
	};

	private static final String[] PREFERRED_URI_ORDER = {
	MediaMetadata.METADATA_KEY_ALBUM_ART_URI,
	MediaMetadata.METADATA_KEY_ART_URI,
	MediaMetadata.METADATA_KEY_DISPLAY_ICON_URI
	};

	private MediaMetadata mCurrentMetadata;
	private MediaStatusUpdateHandler mMediaStatusUpdateHandler;
	private MediaAppInfo mCurrentMediaAppInfo;
	private MediaPlaybackMonitorListener mMonitorListener;

	private Context mContext;

	private final int mIconSize;

	public MediaPlaybackMonitor(Context context, @NonNull MediaPlaybackMonitorListener callback) {
	mContext = context;
	mMonitorListener = callback;
	mIconSize = mContext.getResources().getDimensionPixelSize(R.dimen.stream_media_icon_size);
	}

	public final void start() {
	mMediaStatusUpdateHandler = new MediaStatusUpdateHandler();
	}

	public final void stop() {
	if (mMediaStatusUpdateHandler != null) {
	mMediaStatusUpdateHandler.removeCallbacksAndMessages(null);
	mMediaStatusUpdateHandler = null;
	}
	}

	@Override
	public void onMediaSessionConnected(PlaybackState state, MediaMetadata metaData,
	MediaAppInfo appInfo) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "MediaSession onConnected called");
	}

	// If the current media app is not the same as the new media app, reset
	// the media app in MediaStreamManager
	if (mCurrentMediaAppInfo == null
	\|\| !mCurrentMediaAppInfo.getPackageName().equals(appInfo.getPackageName())) {
	mMonitorListener.onNewAppConnected();
	if (mMediaStatusUpdateHandler != null) {
	mMediaStatusUpdateHandler.removeCallbacksAndMessages(null);
	}
	mCurrentMediaAppInfo = appInfo;
	}

	if (metaData != null) {
	onMetadataChanged(metaData);
	}

	if (state != null) {
	onPlaybackStateChanged(state);
	}
	}

	@Override
	public void onPlaybackStateChanged(@Nullable PlaybackState state) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "onPlaybackStateChanged called " + state.getState());
	}

	if (state == null) {
	Log.w(TAG, "playback state is null in onPlaybackStateChanged");
	mMonitorListener.removeMediaStreamCard();
	return;
	}

	if (mMonitorListener != null) {
	mMonitorListener.onPlaybackStateChanged(state);
	}
	}

	@Override
	public void onMetadataChanged(@Nullable MediaMetadata metadata) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "onMetadataChanged called");
	}
	if (metadata == null) {
	mMonitorListener.removeMediaStreamCard();
	return;
	}
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "received " + metadata.getDescription());
	}
	// Compare the new metadata and the last we have posted notification for. If both
	// metadata and album art are the same, just ignore and return. If the album art is new,
	// update the stream item with the new album art.
	MediaDescription currentDescription = mCurrentMetadata == null ?
	null : mCurrentMetadata.getDescription();

	if (!MediaUtils.isSameMediaDescription(metadata.getDescription(), currentDescription)) {
	Message msg =
	mMediaStatusUpdateHandler.obtainMessage(MSG_UPDATE_METADATA, metadata);
	// Remove obsolete notifications in the queue.
	mMediaStatusUpdateHandler.removeMessages(MSG_UPDATE_METADATA);
	mMediaStatusUpdateHandler.sendMessage(msg);
	} else {
	Bitmap newBitmap = metadata.getDescription().getIconBitmap();
	if (newBitmap == null) {
	return;
	}
	if (newBitmap.sameAs(mMediaStatusUpdateHandler.getCurrentIcon())) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Received duplicate metadata, ignoring...");
	}
	} else {
	// same metadata, but new album art
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Received metadata with new album art");
	}
	Message msg = mMediaStatusUpdateHandler
	.obtainMessage(MSG_NEW_ALBUM_ART_RECEIVED, newBitmap);
	mMediaStatusUpdateHandler.removeMessages(MSG_NEW_ALBUM_ART_RECEIVED);
	mMediaStatusUpdateHandler.sendMessage(msg);
	}
	}
	}

	@Override
	public void onSessionDestroyed() {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Media session destroyed");
	}
	mMonitorListener.removeMediaStreamCard();
	}

	private class BitmapCallback extends BitmapDownloader.BitmapCallback {
	final private int mSeq;

	public BitmapCallback(int seq) {
	mSeq = seq;
	}

	@Override
	public void onBitmapRetrieved(Bitmap bitmap) {
	if (mMediaStatusUpdateHandler == null) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "The callback comes after we finish");
	}
	return;
	}
	Message msg = mMediaStatusUpdateHandler.obtainMessage(MSG_IMAGE_DOWNLOADED,
	mSeq, 0, bitmap);
	mMediaStatusUpdateHandler.sendMessage(msg);
	}
	}

	private class MediaStatusUpdateHandler extends Handler {
	private int mSeq = 0;
	private BitmapCallback mCallback;
	private MediaMetadata mMetadata;
	private String mTitle;
	private String mSubtitle;
	private Bitmap mIcon;
	private Uri mIconUri;
	private final BitmapDownloader mDownloader = BitmapDownloader.getInstance(mContext);

	private void extractMetadata(MediaMetadata metadata) {
	if (metadata == mMetadata) {
	// We are up to date and must return here, because we've already recycled the bitmap
	// inside it.
	return;
	}
	// keep a reference so we know which metadata we have stored.
	mMetadata = metadata;
	MediaDescription description = metadata.getDescription();
	mTitle = description.getTitle() == null ? null : description.getTitle().toString();
	mSubtitle = description.getSubtitle() == null ?
	null : description.getSubtitle().toString();
	final Bitmap originalBitmap = getMetadataBitmap(metadata);
	if (originalBitmap != null) {
	mIcon = originalBitmap;
	} else {
	mIcon = null;
	}
	mIconUri = getMetadataIconUri(metadata);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Album Art Uri: " + mIconUri);
	}
	}

	private Uri getMetadataIconUri(MediaMetadata metadata) {
	// Get the best Uri we can find
	for (int i = 0; i < PREFERRED_URI_ORDER.length; i++) {
	String iconUri = metadata.getString(PREFERRED_URI_ORDER[i]);
	if (!TextUtils.isEmpty(iconUri)) {
	return Uri.parse(iconUri);
	}
	}
	return null;
	}

	private Bitmap getMetadataBitmap(MediaMetadata metadata) {
	// Get the best art bitmap we can find
	for (int i = 0; i < PREFERRED_BITMAP_ORDER.length; i++) {
	Bitmap bitmap = metadata.getBitmap(PREFERRED_BITMAP_ORDER[i]);
	if (bitmap != null) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Retrieved bitmap type: " + PREFERRED_BITMAP_ORDER[i]
	+ " w: " + bitmap.getWidth()
	+ " h: " + bitmap.getHeight());
	}
	return bitmap;
	}
	}
	return null;
	}

	public Bitmap getCurrentIcon() {
	return mIcon;
	}

	@Override
	public void handleMessage(Message msg) {
	MediaAppInfo mediaAppInfo = mCurrentMediaAppInfo;
	int color = mediaAppInfo.getMediaClientAccentColor();
	String appName = mediaAppInfo.getAppName();
	switch (msg.what) {
	case MSG_UPDATE_METADATA:
	mSeq++;
	MediaMetadata metadata = (MediaMetadata) msg.obj;
	if (metadata == null) {
	Log.w(TAG, "media metadata is null!");
	return;
	}
	extractMetadata(metadata);
	if (mCallback != null) {
	// it's ok to cancel a callback that has already been called, the downloader
	// will just ignore the operation.
	mDownloader.cancelDownload(mCallback);
	mCallback = null;
	}
	if (mIcon != null) {
	mMonitorListener.onMetadataChanged(mTitle, mSubtitle, mIcon,
	color, appName);
	} else if (mIconUri != null) {
	mCallback = new BitmapCallback(mSeq);
	mDownloader.getBitmap(
	new BitmapWorkerOptions.Builder(mContext)
	.resource(mIconUri).width(mIconSize)
	.height(mIconSize).build(), mCallback);
	} else {
	mMonitorListener.onMetadataChanged(mTitle, mSubtitle, mIcon,
	color, appName);
	}
	// Only set mCurrentMetadata after we have updated the listener (if the
	// bitmap is downloaded asynchronously, that is fine too. The stream card will
	// be posted, when image is downloaded.)
	mCurrentMetadata = metadata;
	break;

	case MSG_IMAGE_DOWNLOADED:
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Image downloaded...");
	}
	int seq = msg.arg1;
	Bitmap bitmap = (Bitmap) msg.obj;
	if (seq == mSeq) {
	mMonitorListener.onMetadataChanged(mTitle, mSubtitle, bitmap, color, appName);
	}
	break;

	case MSG_NEW_ALBUM_ART_RECEIVED:
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Received a new album art...");
	}
	Bitmap newAlbumArt = (Bitmap) msg.obj;
	mMonitorListener.onAlbumArtUpdated(newAlbumArt);
	break;
	default:
	}
	}
	}
	}