| /* |
| * Copyright (C) 2007 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.music; |
| |
| import android.app.Activity; |
| import android.app.SearchManager; |
| import android.content.ComponentName; |
| import android.content.Intent; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.drawable.BitmapDrawable; |
| import android.media.AudioManager; |
| import android.media.MediaDescription; |
| import android.media.MediaMetadata; |
| import android.media.browse.MediaBrowser; |
| import android.media.session.MediaController; |
| import android.media.session.PlaybackState; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.provider.MediaStore; |
| import android.text.Layout; |
| import android.text.TextUtils.TruncateAt; |
| import android.util.Log; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewConfiguration; |
| import android.view.Window; |
| import android.widget.ImageButton; |
| import android.widget.ImageView; |
| import android.widget.LinearLayout; |
| import android.widget.ProgressBar; |
| import android.widget.SeekBar; |
| import android.widget.SeekBar.OnSeekBarChangeListener; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.android.music.utils.LogHelper; |
| import com.android.music.utils.MediaIDHelper; |
| import com.android.music.utils.MusicProvider; |
| |
| /* |
| This is the Now Playing Activity |
| */ |
| public class MediaPlaybackActivity |
| extends Activity implements View.OnTouchListener, View.OnLongClickListener { |
| private static final String TAG = LogHelper.makeLogTag(MediaPlaybackActivity.class); |
| |
| private long mStartSeekPos = 0; |
| private long mLastSeekEventTime; |
| private RepeatingImageButton mPrevButton; |
| private ImageButton mPlayPauseButton; |
| private RepeatingImageButton mNextButton; |
| private ImageButton mRepeatButton; |
| private ImageButton mShuffleButton; |
| private ImageButton mQueueButton; |
| private int mTouchSlop; |
| |
| private ImageView mAlbumArt; |
| private TextView mCurrentTime; |
| private TextView mTotalTime; |
| private TextView mArtistName; |
| private TextView mAlbumName; |
| private TextView mTrackName; |
| private LinearLayout mTrackInfo; |
| private ProgressBar mProgress; |
| private BitmapDrawable mDefaultAlbumArt; |
| private Toast mToast; |
| |
| private MediaBrowser mMediaBrowser; |
| private final Handler mHandler = new Handler(); |
| |
| /** Called when the activity is first created. */ |
| @Override |
| public void onCreate(Bundle icicle) { |
| LogHelper.d(TAG, "onCreate()"); |
| super.onCreate(icicle); |
| setVolumeControlStream(AudioManager.STREAM_MUSIC); |
| |
| requestWindowFeature(Window.FEATURE_NO_TITLE); |
| setContentView(R.layout.audio_player); |
| |
| mCurrentTime = (TextView) findViewById(R.id.currenttime); |
| mTotalTime = (TextView) findViewById(R.id.totaltime); |
| mProgress = (ProgressBar) findViewById(android.R.id.progress); |
| mAlbumArt = (ImageView) findViewById(R.id.album); |
| mArtistName = (TextView) findViewById(R.id.artistname); |
| mAlbumName = (TextView) findViewById(R.id.albumname); |
| mTrackName = (TextView) findViewById(R.id.trackname); |
| mTrackInfo = (LinearLayout) findViewById(R.id.trackinfo); |
| |
| Bitmap b = BitmapFactory.decodeResource(getResources(), R.drawable.albumart_mp_unknown); |
| mDefaultAlbumArt = new BitmapDrawable(getResources(), b); |
| // no filter or dither, it's a lot faster and we can't tell the difference |
| mDefaultAlbumArt.setFilterBitmap(false); |
| mDefaultAlbumArt.setDither(false); |
| |
| /* Set metadata listeners */ |
| View v = (View) mArtistName.getParent(); |
| v.setOnTouchListener(this); |
| v.setOnLongClickListener(this); |
| v = (View) mAlbumName.getParent(); |
| v.setOnTouchListener(this); |
| v.setOnLongClickListener(this); |
| v = (View) mTrackName.getParent(); |
| v.setOnTouchListener(this); |
| v.setOnLongClickListener(this); |
| |
| /* Set button listeners */ |
| mPrevButton = (RepeatingImageButton) findViewById(R.id.prev); |
| mPrevButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| if (getMediaController() == null) return; |
| if (getMediaController().getPlaybackState().getPosition() < 2000) { |
| getMediaController().getTransportControls().skipToPrevious(); |
| } else { |
| getMediaController().getTransportControls().seekTo(0); |
| getMediaController().getTransportControls().play(); |
| } |
| } |
| }); |
| mPrevButton.setRepeatListener(new RepeatingImageButton.RepeatListener() { |
| public void onRepeat(View v, long howlong, int repcnt) { |
| scanBackward(repcnt, howlong); |
| } |
| }, 260); |
| mPlayPauseButton = (ImageButton) findViewById(R.id.pause); |
| mPlayPauseButton.requestFocus(); |
| mPlayPauseButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| if (getMediaController() != null) { |
| if (getMediaController().getPlaybackState().getState() |
| != PlaybackState.STATE_PLAYING) { |
| getMediaController().getTransportControls().play(); |
| } else { |
| getMediaController().getTransportControls().pause(); |
| } |
| } |
| } |
| }); |
| mNextButton = (RepeatingImageButton) findViewById(R.id.next); |
| mNextButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| if (getMediaController() == null) return; |
| getMediaController().getTransportControls().skipToNext(); |
| } |
| }); |
| mNextButton.setRepeatListener(new RepeatingImageButton.RepeatListener() { |
| public void onRepeat(View v, long howlong, int repcnt) { |
| scanForward(repcnt, howlong); |
| } |
| }, 260); |
| mQueueButton = (ImageButton) findViewById(R.id.curplaylist); |
| mQueueButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| LogHelper.d(TAG, "mQueueButton onClick"); |
| MediaBrowser.MediaItem parentItem = new MediaBrowser.MediaItem( |
| new MediaDescription.Builder() |
| .setMediaId(MediaIDHelper.createBrowseCategoryMediaID( |
| MediaIDHelper.MEDIA_ID_MUSICS_BY_PLAYLIST, |
| MediaIDHelper.MEDIA_ID_NOW_PLAYING)) |
| .setTitle("Now Playing") |
| .build(), |
| MediaBrowser.MediaItem.FLAG_BROWSABLE); |
| Intent intent = new Intent(Intent.ACTION_PICK) |
| .setDataAndType(Uri.EMPTY, "vnd.android.cursor.dir/track") |
| .putExtra(MusicUtils.TAG_WITH_TABS, false) |
| .putExtra(MusicUtils.TAG_PARENT_ITEM, parentItem); |
| startActivity(intent); |
| } |
| }); |
| mShuffleButton = ((ImageButton) findViewById(R.id.shuffle)); |
| mShuffleButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| toggleShuffle(); |
| } |
| }); |
| mRepeatButton = ((ImageButton) findViewById(R.id.repeat)); |
| mRepeatButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| LogHelper.d(TAG, "Repeat button clicked"); |
| if (getMediaController() == null) return; |
| Bundle extras = getMediaController().getExtras(); |
| if (extras == null) return; |
| MediaPlaybackService.RepeatMode repeatMode = |
| MediaPlaybackService.RepeatMode |
| .values()[extras.getInt(MediaPlaybackService.REPEAT_MODE)]; |
| MediaPlaybackService.RepeatMode nextRepeatMode; |
| switch (repeatMode) { |
| case REPEAT_NONE: |
| nextRepeatMode = MediaPlaybackService.RepeatMode.REPEAT_ALL; |
| showToast(R.string.repeat_all_notif); |
| break; |
| case REPEAT_ALL: |
| nextRepeatMode = MediaPlaybackService.RepeatMode.REPEAT_CURRENT; |
| showToast(R.string.repeat_current_notif); |
| break; |
| case REPEAT_CURRENT: |
| default: |
| nextRepeatMode = MediaPlaybackService.RepeatMode.REPEAT_NONE; |
| showToast(R.string.repeat_off_notif); |
| break; |
| } |
| setRepeatMode(nextRepeatMode); |
| // TODO(siyuanh): Should use a callback to register changes on service side |
| setRepeatButtonImage(nextRepeatMode); |
| } |
| }); |
| |
| if (mProgress instanceof SeekBar) { |
| SeekBar seeker = (SeekBar) mProgress; |
| seeker.setOnSeekBarChangeListener(new OnSeekBarChangeListener() { |
| boolean mmFromTouch = false; |
| public void onStartTrackingTouch(SeekBar bar) { |
| mLastSeekEventTime = 0; |
| mmFromTouch = true; |
| } |
| public void onProgressChanged(SeekBar bar, int progress, boolean fromuser) { |
| if (!fromuser || (getMediaController() == null)) return; |
| long now = SystemClock.elapsedRealtime(); |
| if ((now - mLastSeekEventTime) > 250) { |
| mLastSeekEventTime = now; |
| long duration = getMediaController().getMetadata().getLong( |
| MediaMetadata.METADATA_KEY_DURATION); |
| long position = duration * progress / 1000; |
| getMediaController().getTransportControls().seekTo(position); |
| // trackball event, allow progress updates |
| if (!mmFromTouch) { |
| updateProgressBar(); |
| } |
| } |
| } |
| public void onStopTrackingTouch(SeekBar bar) { |
| mmFromTouch = false; |
| } |
| }); |
| } else { |
| LogHelper.d(TAG, "Seeking not supported"); |
| } |
| mProgress.setMax(1000); |
| |
| mTouchSlop = ViewConfiguration.get(this).getScaledTouchSlop(); |
| |
| Log.d(TAG, "Creating MediaBrowser"); |
| mMediaBrowser = new MediaBrowser(this, new ComponentName(this, MediaPlaybackService.class), |
| mConnectionCallback, null); |
| } |
| |
| // Receive callbacks from the MediaController. Here we update our state such as which queue |
| // is being shown, the current title and description and the PlaybackState. |
| private MediaController.Callback mMediaControllerCallback = new MediaController.Callback() { |
| |
| @Override |
| public void onSessionDestroyed() { |
| LogHelper.d(TAG, "Session destroyed. Need to fetch a new Media Session"); |
| } |
| |
| @Override |
| public void onPlaybackStateChanged(PlaybackState state) { |
| if (state == null) { |
| return; |
| } |
| LogHelper.d(TAG, "Received playback state change to state ", state.toString()); |
| updateProgressBar(); |
| setPauseButtonImage(); |
| } |
| |
| @Override |
| public void onMetadataChanged(MediaMetadata metadata) { |
| if (metadata == null) { |
| return; |
| } |
| LogHelper.d(TAG, "Received updated metadata: ", metadata); |
| updateTrackInfo(); |
| } |
| }; |
| |
| private MediaBrowser.ConnectionCallback mConnectionCallback = |
| new MediaBrowser.ConnectionCallback() { |
| @Override |
| public void onConnected() { |
| Log.d(TAG, "onConnected: session token " + mMediaBrowser.getSessionToken()); |
| if (mMediaBrowser.getSessionToken() == null) { |
| throw new IllegalArgumentException("No Session token"); |
| } |
| MediaController mediaController = new MediaController( |
| MediaPlaybackActivity.this, mMediaBrowser.getSessionToken()); |
| mediaController.registerCallback(mMediaControllerCallback); |
| MediaPlaybackActivity.this.setMediaController(mediaController); |
| mRepeatButton.setVisibility(View.VISIBLE); |
| mShuffleButton.setVisibility(View.VISIBLE); |
| mQueueButton.setVisibility(View.VISIBLE); |
| setRepeatButtonImage(null); |
| setShuffleButtonImage(); |
| setPauseButtonImage(); |
| updateTrackInfo(); |
| mHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| long delay = updateProgressBar(); |
| mHandler.postDelayed(this, delay); |
| } |
| }); |
| } |
| |
| @Override |
| public void onConnectionFailed() { |
| Log.d(TAG, "onConnectionFailed"); |
| } |
| |
| @Override |
| public void onConnectionSuspended() { |
| Log.d(TAG, "onConnectionSuspended"); |
| mHandler.removeCallbacksAndMessages(null); |
| MediaPlaybackActivity.this.setMediaController(null); |
| } |
| }; |
| |
| int mInitialX = -1; |
| int mLastX = -1; |
| int mTextWidth = 0; |
| int mViewWidth = 0; |
| boolean mDraggingLabel = false; |
| |
| TextView textViewForContainer(View v) { |
| View vv = v.findViewById(R.id.artistname); |
| if (vv != null) return (TextView) vv; |
| vv = v.findViewById(R.id.albumname); |
| if (vv != null) return (TextView) vv; |
| vv = v.findViewById(R.id.trackname); |
| if (vv != null) return (TextView) vv; |
| return null; |
| } |
| |
| public boolean onTouch(View v, MotionEvent event) { |
| int action = event.getAction(); |
| TextView tv = textViewForContainer(v); |
| if (tv == null) { |
| return false; |
| } |
| if (action == MotionEvent.ACTION_DOWN) { |
| v.setBackgroundColor(0xff606060); |
| mInitialX = mLastX = (int) event.getX(); |
| mDraggingLabel = false; |
| } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) { |
| v.setBackgroundColor(0); |
| if (mDraggingLabel) { |
| Message msg = mLabelScroller.obtainMessage(0, tv); |
| mLabelScroller.sendMessageDelayed(msg, 1000); |
| } |
| } else if (action == MotionEvent.ACTION_MOVE) { |
| if (mDraggingLabel) { |
| int scrollx = tv.getScrollX(); |
| int x = (int) event.getX(); |
| int delta = mLastX - x; |
| if (delta != 0) { |
| mLastX = x; |
| scrollx += delta; |
| if (scrollx > mTextWidth) { |
| // scrolled the text completely off the view to the left |
| scrollx -= mTextWidth; |
| scrollx -= mViewWidth; |
| } |
| if (scrollx < -mViewWidth) { |
| // scrolled the text completely off the view to the right |
| scrollx += mViewWidth; |
| scrollx += mTextWidth; |
| } |
| tv.scrollTo(scrollx, 0); |
| } |
| return true; |
| } |
| int delta = mInitialX - (int) event.getX(); |
| if (Math.abs(delta) > mTouchSlop) { |
| // start moving |
| mLabelScroller.removeMessages(0, tv); |
| |
| // Only turn ellipsizing off when it's not already off, because it |
| // causes the scroll position to be reset to 0. |
| if (tv.getEllipsize() != null) { |
| tv.setEllipsize(null); |
| } |
| Layout ll = tv.getLayout(); |
| // layout might be null if the text just changed, or ellipsizing |
| // was just turned off |
| if (ll == null) { |
| return false; |
| } |
| // get the non-ellipsized line width, to determine whether scrolling |
| // should even be allowed |
| mTextWidth = (int) tv.getLayout().getLineWidth(0); |
| mViewWidth = tv.getWidth(); |
| if (mViewWidth > mTextWidth) { |
| tv.setEllipsize(TruncateAt.END); |
| v.cancelLongPress(); |
| return false; |
| } |
| mDraggingLabel = true; |
| tv.setHorizontalFadingEdgeEnabled(true); |
| v.cancelLongPress(); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| Handler mLabelScroller = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| TextView tv = (TextView) msg.obj; |
| int x = tv.getScrollX(); |
| x = x * 3 / 4; |
| tv.scrollTo(x, 0); |
| if (x == 0) { |
| tv.setEllipsize(TruncateAt.END); |
| } else { |
| Message newmsg = obtainMessage(0, tv); |
| mLabelScroller.sendMessageDelayed(newmsg, 15); |
| } |
| } |
| }; |
| |
| public boolean onLongClick(View view) { |
| CharSequence title = null; |
| String mime = null; |
| String query = null; |
| if (getMediaController() == null) { |
| LogHelper.d(TAG, "No media controller avalable yet"); |
| return true; |
| } |
| MediaMetadata metadata = getMediaController().getMetadata(); |
| if (metadata == null) { |
| LogHelper.d(TAG, "No metadata avalable yet"); |
| return true; |
| } |
| String artist = metadata.getString(MediaMetadata.METADATA_KEY_ARTIST); |
| String album = metadata.getString(MediaMetadata.METADATA_KEY_ALBUM); |
| String song = metadata.getString(MediaMetadata.METADATA_KEY_TITLE); |
| long audioid = metadata.getLong(MediaMetadata.METADATA_KEY_MEDIA_ID); |
| |
| if (album == null && artist == null && song != null && song.startsWith("recording")) { |
| LogHelper.d(TAG, "Item is not music"); |
| return false; |
| } |
| |
| if (audioid < 0) { |
| return false; |
| } |
| |
| boolean knownartist = (artist != null) && !MediaStore.UNKNOWN_STRING.equals(artist); |
| boolean knownalbum = (album != null) && !MediaStore.UNKNOWN_STRING.equals(album); |
| |
| if (knownartist && view.equals(mArtistName.getParent())) { |
| title = artist; |
| query = artist; |
| mime = MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE; |
| } else if (knownalbum && view.equals(mAlbumName.getParent())) { |
| title = album; |
| if (knownartist) { |
| query = artist + " " + album; |
| } else { |
| query = album; |
| } |
| mime = MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE; |
| } else if (view.equals(mTrackName.getParent()) || !knownartist || !knownalbum) { |
| if ((song == null) || MediaStore.UNKNOWN_STRING.equals(song)) { |
| // A popup of the form "Search for null/'' using ..." is pretty |
| // unhelpful, plus, we won't find any way to buy it anyway. |
| return true; |
| } |
| |
| title = song; |
| if (knownartist) { |
| query = artist + " " + song; |
| } else { |
| query = song; |
| } |
| mime = "audio/*"; // the specific type doesn't matter, so don't bother retrieving it |
| } else { |
| throw new RuntimeException("shouldn't be here"); |
| } |
| title = getString(R.string.mediasearch, title); |
| |
| Intent i = new Intent(); |
| i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| i.setAction(MediaStore.INTENT_ACTION_MEDIA_SEARCH); |
| i.putExtra(SearchManager.QUERY, query); |
| if (knownartist) { |
| i.putExtra(MediaStore.EXTRA_MEDIA_ARTIST, artist); |
| } |
| if (knownalbum) { |
| i.putExtra(MediaStore.EXTRA_MEDIA_ALBUM, album); |
| } |
| i.putExtra(MediaStore.EXTRA_MEDIA_TITLE, song); |
| i.putExtra(MediaStore.EXTRA_MEDIA_FOCUS, mime); |
| |
| startActivity(Intent.createChooser(i, title)); |
| return true; |
| } |
| |
| @Override |
| public void onStart() { |
| LogHelper.d(TAG, "onStart()"); |
| super.onStart(); |
| mMediaBrowser.connect(); |
| } |
| |
| @Override |
| public void onStop() { |
| LogHelper.d(TAG, "onStop()"); |
| mMediaBrowser.disconnect(); |
| super.onStop(); |
| } |
| |
| @Override |
| public void onResume() { |
| LogHelper.d(TAG, "onResume()"); |
| super.onResume(); |
| updateTrackInfo(); |
| setPauseButtonImage(); |
| } |
| |
| @Override |
| public void onDestroy() { |
| LogHelper.d(TAG, "onDestroy()"); |
| super.onDestroy(); |
| } |
| |
| private void scanBackward(int repcnt, long delta) { |
| if (getMediaController() == null) return; |
| if (repcnt == 0) { |
| mStartSeekPos = getMediaController().getPlaybackState().getPosition(); |
| mLastSeekEventTime = 0; |
| } else { |
| if (delta < 5000) { |
| // seek at 10x speed for the first 5 seconds |
| delta = delta * 10; |
| } else { |
| // seek at 40x after that |
| delta = 50000 + (delta - 5000) * 40; |
| } |
| long newpos = mStartSeekPos - delta; |
| if (newpos < 0) { |
| // move to previous track |
| getMediaController().getTransportControls().skipToPrevious(); |
| long duration = getMediaController().getMetadata().getLong( |
| MediaMetadata.METADATA_KEY_DURATION); |
| mStartSeekPos += duration; |
| newpos += duration; |
| } |
| if (((delta - mLastSeekEventTime) > 250) || repcnt < 0) { |
| getMediaController().getTransportControls().seekTo(newpos); |
| mLastSeekEventTime = delta; |
| } |
| updateProgressBar(); |
| } |
| } |
| |
| private void scanForward(int repcnt, long delta) { |
| if (getMediaController() == null) return; |
| if (repcnt == 0) { |
| mStartSeekPos = getMediaController().getPlaybackState().getPosition(); |
| mLastSeekEventTime = 0; |
| } else { |
| if (delta < 5000) { |
| // seek at 10x speed for the first 5 seconds |
| delta = delta * 10; |
| } else { |
| // seek at 40x after that |
| delta = 50000 + (delta - 5000) * 40; |
| } |
| long newpos = mStartSeekPos + delta; |
| long duration = |
| getMediaController().getMetadata().getLong(MediaMetadata.METADATA_KEY_DURATION); |
| if (newpos >= duration) { |
| // move to next track |
| getMediaController().getTransportControls().skipToNext(); |
| mStartSeekPos -= duration; // is OK to go negative |
| newpos -= duration; |
| } |
| if (((delta - mLastSeekEventTime) > 250) || repcnt < 0) { |
| getMediaController().getTransportControls().seekTo(newpos); |
| mLastSeekEventTime = delta; |
| } |
| updateProgressBar(); |
| } |
| } |
| |
| private void toggleShuffle() { |
| // TODO(b/36371715): Implement shuffle for SHUFFLE_NORMAL, SHUFFLE_AUTO, SHUFFLE_NONE |
| LogHelper.d(TAG, "Shuffle not implemented yet"); |
| Toast.makeText(this, "Shuffle not implemented yet", Toast.LENGTH_SHORT).show(); |
| } |
| |
| private void setRepeatMode(MediaPlaybackService.RepeatMode repeatMode) { |
| Bundle extras = new Bundle(); |
| extras.putInt(MediaPlaybackService.REPEAT_MODE, repeatMode.ordinal()); |
| getMediaController().getTransportControls().sendCustomAction( |
| MediaPlaybackService.CMD_REPEAT, extras); |
| } |
| |
| private void setRepeatButtonImage(MediaPlaybackService.RepeatMode repeatMode) { |
| if (getMediaController() == null) return; |
| Bundle extras = getMediaController().getExtras(); |
| if (extras == null) return; |
| if (repeatMode == null) { |
| repeatMode = MediaPlaybackService.RepeatMode |
| .values()[extras.getInt(MediaPlaybackService.REPEAT_MODE)]; |
| } |
| switch (repeatMode) { |
| case REPEAT_CURRENT: |
| mRepeatButton.setImageResource(R.drawable.ic_mp_repeat_once_btn); |
| break; |
| case REPEAT_ALL: |
| mRepeatButton.setImageResource(R.drawable.ic_mp_repeat_all_btn); |
| break; |
| case REPEAT_NONE: |
| default: |
| mRepeatButton.setImageResource(R.drawable.ic_mp_repeat_off_btn); |
| break; |
| } |
| } |
| |
| private void showToast(int resid) { |
| if (mToast == null) { |
| mToast = Toast.makeText(this, "", Toast.LENGTH_SHORT); |
| } |
| mToast.setText(resid); |
| mToast.show(); |
| } |
| |
| private void setShuffleButtonImage() { |
| if (getMediaController() == null) return; |
| mShuffleButton.setImageResource(R.drawable.ic_mp_shuffle_off_btn); |
| } |
| |
| private void setPauseButtonImage() { |
| if (getMediaController() == null) { |
| return; |
| } |
| if (getMediaController().getPlaybackState().getState() != PlaybackState.STATE_PLAYING) { |
| mPlayPauseButton.setImageResource(android.R.drawable.ic_media_play); |
| } else { |
| mPlayPauseButton.setImageResource(android.R.drawable.ic_media_pause); |
| } |
| } |
| |
| private long updateProgressBar() { |
| MediaController mediaController = getMediaController(); |
| if (mediaController == null || mediaController.getMetadata() == null |
| || mediaController.getPlaybackState() == null) { |
| return 500; |
| } |
| long duration = mediaController.getMetadata().getLong(MediaMetadata.METADATA_KEY_DURATION); |
| long pos = mediaController.getPlaybackState().getPosition(); |
| if ((pos >= 0) && (duration > 0)) { |
| mCurrentTime.setText(MusicUtils.makeTimeString(this, pos / 1000)); |
| int progress = (int) (1000 * pos / duration); |
| mProgress.setProgress(progress); |
| |
| if (mediaController.getPlaybackState().getState() == PlaybackState.STATE_PLAYING) { |
| mCurrentTime.setVisibility(View.VISIBLE); |
| } else { |
| // blink the counter |
| int vis = mCurrentTime.getVisibility(); |
| mCurrentTime.setVisibility(vis == View.INVISIBLE ? View.VISIBLE : View.INVISIBLE); |
| return 500; |
| } |
| } else { |
| mCurrentTime.setText("--:--"); |
| mProgress.setProgress(1000); |
| } |
| // calculate the number of milliseconds until the next full second, so |
| // the counter can be updated at just the right time |
| long remaining = 1000 - (pos % 1000); |
| |
| // approximate how often we would need to refresh the slider to |
| // move it smoothly |
| int width = mProgress.getWidth(); |
| if (width == 0) width = 320; |
| long smoothrefreshtime = duration / width; |
| |
| if (smoothrefreshtime > remaining) return remaining; |
| if (smoothrefreshtime < 20) return 20; |
| return smoothrefreshtime; |
| } |
| |
| private void updateTrackInfo() { |
| LogHelper.d(TAG, "updateTrackInfo()"); |
| if (getMediaController() == null) { |
| return; |
| } |
| MediaMetadata metadata = getMediaController().getMetadata(); |
| if (metadata == null) { |
| return; |
| } |
| mTrackInfo.setVisibility(View.VISIBLE); |
| mTrackName.setText(metadata.getString(MediaMetadata.METADATA_KEY_TITLE)); |
| LogHelper.d(TAG, "Track Name: ", mTrackName.getText()); |
| String artistName = metadata.getString(MediaMetadata.METADATA_KEY_ARTIST); |
| if (artistName.equals(MusicProvider.UNKOWN)) { |
| artistName = getString(R.string.unknown_artist_name); |
| } |
| mArtistName.setText(artistName); |
| String albumName = metadata.getString(MediaMetadata.METADATA_KEY_ALBUM); |
| if (albumName.equals(MusicProvider.UNKOWN)) { |
| albumName = getString(R.string.unknown_album_name); |
| } |
| mAlbumName.setText(albumName); |
| Bitmap albumArt = metadata.getBitmap(MediaMetadata.METADATA_KEY_ALBUM_ART); |
| if (albumArt != null) { |
| mAlbumArt.setImageBitmap(albumArt); |
| } else { |
| mAlbumArt.setImageDrawable(mDefaultAlbumArt); |
| } |
| mAlbumArt.setVisibility(View.VISIBLE); |
| |
| long duration = metadata.getLong(MediaMetadata.METADATA_KEY_DURATION); |
| mTotalTime.setText(MusicUtils.makeTimeString(this, duration / 1000)); |
| } |
| } |