if (mService == null) {            return;        }        try {            int shuffle = mService.getShuffleMode();            if (shuffle == MediaPlaybackService.SHUFFLE_NONE) {                mService.setShuffleMode(MediaPlaybackService.SHUFFLE_NORMAL);                if (mService.getRepeatMode() == MediaPlaybackService.REPEAT_CURRENT) {                    mService.setRepeatMode(MediaPlaybackService.REPEAT_ALL);                    setRepeatButtonImage();                }                showToast(R.string.shuffle_on_notif);            } else if (shuffle == MediaPlaybackService.SHUFFLE_NORMAL ||                    shuffle == MediaPlaybackService.SHUFFLE_AUTO) {                mService.setShuffleMode(MediaPlaybackService.SHUFFLE_NONE);                showToast(R.string.shuffle_off_notif);            } else {                Log.e("MediaPlaybackActivity", "Invalid shuffle mode: " + shuffle);            }            setShuffleButtonImage();        } catch (RemoteException ex) {        }    }        private void cycleRepeat() {        if (mService == null) {            return;        }        try {            int mode = mService.getRepeatMode();            if (mode == MediaPlaybackService.REPEAT_NONE) {                mService.setRepeatMode(MediaPlaybackService.REPEAT_ALL);                showToast(R.string.repeat_all_notif);            } else if (mode == MediaPlaybackService.REPEAT_ALL) {                mService.setRepeatMode(MediaPlaybackService.REPEAT_CURRENT);                if (mService.getShuffleMode() != MediaPlaybackService.SHUFFLE_NONE) {                    mService.setShuffleMode(MediaPlaybackService.SHUFFLE_NONE);                    setShuffleButtonImage();                }                showToast(R.string.repeat_current_notif);            } else {                mService.setRepeatMode(MediaPlaybackService.REPEAT_NONE);                showToast(R.string.repeat_off_notif);            }            setRepeatButtonImage();        } catch (RemoteException ex) {        }            }        private void showToast(int resid) {        if (mToast == null) {            mToast = Toast.makeText(this, "", Toast.LENGTH_SHORT);        }        mToast.setText(resid);        mToast.show();    }    private void startPlayback() {        if(mService == null)            return;        Intent intent = getIntent();        String filename = "";        Uri uri = intent.getData();        if (uri != null && uri.toString().length() > 0) {            // If this is a file:// URI, just use the path directly instead            // of going through the open-from-filedescriptor codepath.            String scheme = uri.getScheme();            if ("file".equals(scheme)) {                filename = uri.getPath();            } else {                filename = uri.toString();            }            try {                mOneShot = true;                if (! mRelaunchAfterConfigChange) {                    mService.stop();                    mService.openfile(filename);                    mService.play();                }            } catch (Exception ex) {                Log.d("MediaPlaybackActivity", "couldn't start playback: " + ex);            }        }        updateTrackInfo();        long next = refreshNow();        queueNextRefresh(next);    }    private ServiceConnection osc = new ServiceConnection() {            public void onServiceConnected(ComponentName classname, IBinder obj) {                mService = IMediaPlaybackService.Stub.asInterface(obj);                if (MusicUtils.sService == null) {                    MusicUtils.sService = mService;                }                startPlayback();                try {                    // Assume something is playing when the service says it is,                    // but also if the audio ID is valid but the service is paused.                    if (mService.getAudioId() >= 0 || mService.isPlaying() ||                            mService.getPath() != null) {                        // something is playing now, we're done                        if (mOneShot) {                            mRepeatButton.setVisibility(View.INVISIBLE);                            mShuffleButton.setVisibility(View.INVISIBLE);                            mQueueButton.setVisibility(View.INVISIBLE);                        } else {                            mRepeatButton.setVisibility(View.VISIBLE);                            mShuffleButton.setVisibility(View.VISIBLE);                            mQueueButton.setVisibility(View.VISIBLE);                            setRepeatButtonImage();                            setShuffleButtonImage();                        }                        setPauseButtonImage();                        return;                    }                } catch (RemoteException ex) {                }                // Service is dead or not playing anything. If we got here as part                // of a "play this file" Intent, exit. Otherwise go to the Music                // app start screen.                if (getIntent().getData() == null) {                    Intent intent = new Intent(Intent.ACTION_MAIN);                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);                    intent.setClass(MediaPlaybackActivity.this, MusicBrowserActivity.class);                    startActivity(intent);                }                finish();            }            public void onServiceDisconnected(ComponentName classname) {            }    };    private void setRepeatButtonImage() {        try {            switch (mService.getRepeatMode()) {                case MediaPlaybackService.REPEAT_ALL:                    mRepeatButton.setImageResource(R.drawable.ic_mp_repeat_all_btn);                    break;                case MediaPlaybackService.REPEAT_CURRENT:                    mRepeatButton.setImageResource(R.drawable.ic_mp_repeat_once_btn);                    break;                default:                    mRepeatButton.setImageResource(R.drawable.ic_mp_repeat_off_btn);                    break;            }        } catch (RemoteException ex) {        }    }        private void setShuffleButtonImage() {        try {            switch (mService.getShuffleMode()) {                case MediaPlaybackService.SHUFFLE_NONE:                    mShuffleButton.setImageResource(R.drawable.ic_mp_shuffle_off_btn);                    break;                case MediaPlaybackService.SHUFFLE_AUTO:                    mShuffleButton.setImageResource(R.drawable.ic_mp_partyshuffle_on_btn);                    break;                default:                    mShuffleButton.setImageResource(R.drawable.ic_mp_shuffle_on_btn);                    break;            }        } catch (RemoteException ex) {        }    }        private void setPauseButtonImage() {        try {            if (mService != null && mService.isPlaying()) {                mPauseButton.setImageResource(android.R.drawable.ic_media_pause);            } else {                mPauseButton.setImageResource(android.R.drawable.ic_media_play);            }        } catch (RemoteException ex) {        }    }        private AlbumView mAlbum;    private TextView mCurrentTime;    private TextView mTotalTime;    private TextView mArtistName;    private TextView mAlbumName;    private TextView mTrackName;    private ProgressBar mProgress;    private long mPosOverride = -1;    private long mDuration;    private int seekmethod;    private boolean paused;    private static final int REFRESH = 1;    private static final int QUIT = 2;    private static final int GET_ALBUM_ART = 3;    private static final int ALBUM_ART_DECODED = 4;    private void queueNextRefresh(long delay) {        if (!paused) {            Message msg = mHandler.obtainMessage(REFRESH);            mHandler.removeMessages(REFRESH);            mHandler.sendMessageDelayed(msg, delay);        }    }    private long refreshNow() {        if(mService == null)            return 500;        try {            long pos = mPosOverride < 0 ? mService.position() : mPosOverride;            long remaining = 1000 - (pos % 1000);            if ((pos >= 0) && (mDuration > 0)) {                mCurrentTime.setText(MusicUtils.makeTimeString(this, pos / 1000));                                if (mService.isPlaying()) {                    mCurrentTime.setVisibility(View.VISIBLE);                } else {                    // blink the counter                    int vis = mCurrentTime.getVisibility();                    mCurrentTime.setVisibility(vis == View.INVISIBLE ? View.VISIBLE : View.INVISIBLE);                    remaining = 500;                }                mProgress.setProgress((int) (1000 * pos / mDuration));            } else {                mCurrentTime.setText("--:--");                mProgress.setProgress(1000);            }            // return the number of milliseconds until the next full second, so            // the counter can be updated at just the right time            return remaining;        } catch (RemoteException ex) {        }        return 500;    }        private final Handler mHandler = new Handler() {        @Override        public void handleMessage(Message msg) {            switch (msg.what) {                case ALBUM_ART_DECODED:                    mAlbum.setArtwork((Bitmap)msg.obj);                    mAlbum.invalidate();                    break;                case REFRESH:                    long next = refreshNow();                    queueNextRefresh(next);                    break;                                    case QUIT:                    // This can be moved back to onCreate once the bug that prevents                    // Dialogs from being started from onCreate/onResume is fixed.                    new AlertDialog.Builder(MediaPlaybackActivity.this)                            .setTitle(R.string.service_start_error_title)                            .setMessage(R.string.service_start_error_msg)                            .setPositiveButton(R.string.service_start_error_button,                                    new DialogInterface.OnClickListener() {                                        public void onClick(DialogInterface dialog, int whichButton) {                                            finish();                                        }                                    })                            .setCancelable(false)                            .show();                    break;                default:                    break;            }        }    };    private BroadcastReceiver mStatusListener = new BroadcastReceiver() {        @Override        public void onReceive(Context context, Intent intent) {            String action = intent.getAction();            if (action.equals(MediaPlaybackService.META_CHANGED)) {                // redraw the artist/title info and                // set new max for progress bar                updateTrackInfo();                setPauseButtonImage();                queueNextRefresh(1);            } else if (action.equals(MediaPlaybackService.PLAYBACK_COMPLETE)) {                if (mOneShot) {                    finish();                } else {                    setPauseButtonImage();                }            } else if (action.equals(MediaPlaybackService.PLAYSTATE_CHANGED)) {                setPauseButtonImage();            }        }    };    private void updateTrackInfo() {        if (mService == null) {            return;        }        try {            if (mService.getPath() == null) {                finish();                return;            }            String artistName = mService.getArtistName();            if (MediaFile.UNKNOWN_STRING.equals(artistName)) {                artistName = getString(R.string.unknown_artist_name);            }            mArtistName.setText(artistName);            String albumName = mService.getAlbumName();            int albumid = mService.getAlbumId();            if (MediaFile.UNKNOWN_STRING.equals(albumName)) {                albumName = getString(R.string.unknown_album_name);                albumid = -1;            }            mAlbumName.setText(albumName);            mTrackName.setText(mService.getTrackName());            mAlbumArtHandler.removeMessages(GET_ALBUM_ART);            mAlbumArtHandler.obtainMessage(GET_ALBUM_ART, albumid, 0).sendToTarget();            mDuration = mService.duration();            mTotalTime.setText(MusicUtils.makeTimeString(this, mDuration / 1000));        } catch (RemoteException ex) {            finish();        }    }        public class AlbumArtHandler extends Handler {        private int mAlbumId = -1;                public AlbumArtHandler(Looper looper) {            super(looper);        }        public void handleMessage(Message msg)        {            int albumid = msg.arg1;            if (msg.what == GET_ALBUM_ART && (mAlbumId != albumid || albumid < 0)) {                // while decoding the new image, show the default album art                Message numsg = mHandler.obtainMessage(ALBUM_ART_DECODED, null);                mHandler.removeMessages(ALBUM_ART_DECODED);                mHandler.sendMessageDelayed(numsg, 300);                Bitmap bm = MusicUtils.getArtwork(MediaPlaybackActivity.this, albumid);                if (bm == null) {                    bm = MusicUtils.getArtwork(MediaPlaybackActivity.this, -1);                    albumid = -1;                }                if (bm != null) {                    numsg = mHandler.obtainMessage(ALBUM_ART_DECODED, bm);                    mHandler.removeMessages(ALBUM_ART_DECODED);                    mHandler.sendMessage(numsg);                }                mAlbumId = albumid;            }        }    }        private class Worker implements Runnable {        private final Object mLock = new Object();        private Looper mLooper;                /**         * Creates a worker thread with the given name. The thread         * then runs a {@link android.os.Looper}.         * @param name A name for the new thread         */        Worker(String name) {            Thread t = new Thread(null, this, name);            t.setPriority(Thread.MIN_PRIORITY);            t.start();            synchronized (mLock) {                while (mLooper == null) {                    try {                        mLock.wait();                    } catch (InterruptedException ex) {                    }                }            }        }                public Looper getLooper() {            return mLooper;        }                public void run() {            synchronized (mLock) {                Looper.prepare();                mLooper = Looper.myLooper();                mLock.notifyAll();            }            Looper.loop();        }                public void quit() {            mLooper.quit();        }    }}