mediaplaybackservice.java

来自「Android平台上的media player, iPhone风格」· Java 代码 · 共 1,619 行 · 第 1/4 页

                    numremoved += removeTracks(i, i);
                    i--;
                }
            }
        }
        return numremoved;
    }
    
    public void setShuffleMode(int shufflemode) {
        synchronized(this) {
            if (mShuffleMode == shufflemode) {
                return;
            }
            mShuffleMode = shufflemode;
            if (mShuffleMode == SHUFFLE_AUTO) {
                if (makeAutoShuffleList()) {
                    mPlayListLen = 0;
                    doAutoShuffleUpdate();
                    mPlayPos = 0;
                    openCurrent();
                    play();
                    notifyChange(META_CHANGED);
                } else {
                    // failed to build a list of files to shuffle
                    mShuffleMode = SHUFFLE_NONE;
                }
            }
        }
    }
    public int getShuffleMode() {
        return mShuffleMode;
    }
    
    public void setRepeatMode(int repeatmode) {
        synchronized(this) {
            mRepeatMode = repeatmode;
        }
    }
    public int getRepeatMode() {
        return mRepeatMode;
    }

    public int getMediaMountedCount() {
        return mMediaMountedCount;
    }

    /**
     * Returns the path of the currently playing file, or null if
     * no file is currently playing.
     */
    public String getPath() {
        return mFileToPlay;
    }
    
    /**
     * Returns the rowid of the currently playing file, or -1 if
     * no file is currently playing.
     */
    public int getAudioId() {
        synchronized (this) {
            if (mPlayPos >= 0 && mPlayer.isInitialized()) {
                return mPlayList[mPlayPos];
            }
        }
        return -1;
    }
    
    /**
     * Returns the position in the queue 
     * @return the position in the queue
     */
    public int getQueuePosition() {
        synchronized(this) {
            return mPlayPos;
        }
    }
    
    /**
     * Starts playing the track at the given position in the queue.
     * @param pos The position in the queue of the track that will be played.
     */
    public void setQueuePosition(int pos) {
        synchronized(this) {
            stop(false);
            mPlayPos = pos;
            openCurrent();
            play();
            notifyChange(META_CHANGED);
        }
    }

    public String getArtistName() {
        if (mCursor == null) {
            return null;
        }
        return mCursor.getString(mCursor.getColumnIndex(MediaStore.Audio.Media.ARTIST));
    }
    
    public int getArtistId() {
        if (mCursor == null) {
            return -1;
        }
        return mCursor.getInt(mCursor.getColumnIndex(MediaStore.Audio.Media.ARTIST_ID));
    }

    public String getAlbumName() {
        if (mCursor == null) {
            return null;
        }
        return mCursor.getString(mCursor.getColumnIndex(MediaStore.Audio.Media.ALBUM));
    }

    public int getAlbumId() {
        if (mCursor == null) {
            return -1;
        }
        return mCursor.getInt(mCursor.getColumnIndex(MediaStore.Audio.Media.ALBUM_ID));
    }

    public String getTrackName() {
        if (mCursor == null) {
            return null;
        }
        return mCursor.getString(mCursor.getColumnIndex(MediaStore.Audio.Media.TITLE));
    }

    
    
    /**
     * Returns the duration of the file in milliseconds.
     * Currently this method returns -1 for the duration of MIDI files.
     */
    public long duration() {
        if (mPlayer.isInitialized()) {
            return mPlayer.duration();
        }
        // TODO: when the MIDI engine supports it, return MIDI duration.
        return -1;
    }

    /**
     * Returns the current playback position in milliseconds
     */
    public long position() {
        if (mPlayer.isInitialized()) {
            return mPlayer.position();
        }
        return -1;
    }

    /**
     * Seeks to the position specified.
     *
     * @param pos The position to seek to, in milliseconds
     */
    public long seek(long pos) {
        if (mPlayer.isInitialized()) {
            if (pos < 0) pos = 0;
            if (pos > mPlayer.duration()) pos = mPlayer.duration();
            return mPlayer.seek(pos);
        }
        return -1;
    }

    /**
     * Provides a unified interface for dealing with midi files and
     * other media files.
     */
    private class MultiPlayer {
        private MediaPlayer mMediaPlayer = new MediaPlayer();
        private Handler mHandler;
        private boolean mIsInitialized = false;

        public MultiPlayer() {
            mMediaPlayer.setWakeMode(MediaPlaybackService.this, PowerManager.PARTIAL_WAKE_LOCK);
        }

        public void setDataSourceAsync(String path) {
            try {
                mMediaPlayer.reset();
                mMediaPlayer.setDataSource(path);
                mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
                mMediaPlayer.setOnPreparedListener(preparedlistener);
                mMediaPlayer.prepareAsync();
            } catch (IOException ex) {
                // TODO: notify the user why the file couldn't be opened
                mIsInitialized = false;
                return;
            } catch (IllegalArgumentException ex) {
                // TODO: notify the user why the file couldn't be opened
                mIsInitialized = false;
                return;
            }
            mMediaPlayer.setOnCompletionListener(listener);
            mMediaPlayer.setOnErrorListener(errorListener);
            
            mIsInitialized = true;
        }
        
        public void setDataSource(String path) {
            try {
                mMediaPlayer.reset();
                mMediaPlayer.setOnPreparedListener(null);
                if (path.startsWith("content://")) {
                    mMediaPlayer.setDataSource(MediaPlaybackService.this, Uri.parse(path));
                } else {
                    mMediaPlayer.setDataSource(path);
                }
                mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
                mMediaPlayer.prepare();
            } catch (IOException ex) {
                // TODO: notify the user why the file couldn't be opened
                mIsInitialized = false;
                return;
            } catch (IllegalArgumentException ex) {
                // TODO: notify the user why the file couldn't be opened
                mIsInitialized = false;
                return;
            }
            mMediaPlayer.setOnCompletionListener(listener);
            mMediaPlayer.setOnErrorListener(errorListener);
            
            mIsInitialized = true;
        }
        
        public boolean isInitialized() {
            return mIsInitialized;
        }

        public void start() {
            mMediaPlayer.start();
        }

        public void stop() {
            mMediaPlayer.reset();
            mIsInitialized = false;
        }

        public void pause() {
            mMediaPlayer.pause();
        }
        
        public boolean isPlaying() {
            return mMediaPlayer.isPlaying();
        }

        public void setHandler(Handler handler) {
            mHandler = handler;
        }

        MediaPlayer.OnCompletionListener listener = new MediaPlayer.OnCompletionListener() {
            public void onCompletion(MediaPlayer mp) {
                // Acquire a temporary wakelock, since when we return from
                // this callback the MediaPlayer will release its wakelock
                // and allow the device to go to sleep.
                // This temporary wakelock is released when the RELEASE_WAKELOCK
                // message is processed, but just in case, put a timeout on it.
                mWakeLock.acquire(30000);
                mHandler.sendEmptyMessage(TRACK_ENDED);
                mHandler.sendEmptyMessage(RELEASE_WAKELOCK);
            }
        };

        MediaPlayer.OnPreparedListener preparedlistener = new MediaPlayer.OnPreparedListener() {
            public void onPrepared(MediaPlayer mp) {
                notifyChange(ASYNC_OPEN_COMPLETE);
            }
        };
 
        MediaPlayer.OnErrorListener errorListener = new MediaPlayer.OnErrorListener() {
            public boolean onError(MediaPlayer mp, int what, int extra) {
                switch (what) {
                case MediaPlayer.MEDIA_ERROR_SERVER_DIED:
                    mIsInitialized = false;
                    mMediaPlayer.release();
                    // Creating a new MediaPlayer and settings its wakemode does not
                    // require the media service, so it's OK to do this now, while the
                    // service is still being restarted
                    mMediaPlayer = new MediaPlayer(); 
                    mMediaPlayer.setWakeMode(MediaPlaybackService.this, PowerManager.PARTIAL_WAKE_LOCK);
                    mHandler.sendMessageDelayed(mHandler.obtainMessage(SERVER_DIED), 2000);
                    return true;
                default:
                    break;
                }
                return false;
           }
        };

        public long duration() {
            return mMediaPlayer.getDuration();
        }

        public long position() {
            return mMediaPlayer.getCurrentPosition();
        }

        public long seek(long whereto) {
            mMediaPlayer.seekTo((int) whereto);
            return whereto;
        }
    }

    private final IMediaPlaybackService.Stub mBinder = new IMediaPlaybackService.Stub()
    {
        public void openfileAsync(String path)
        {
            MediaPlaybackService.this.openAsync(path);
        }
        public void openfile(String path)
        {
            MediaPlaybackService.this.open(path, true);
        }
        public void open(int [] list, int position) {
            MediaPlaybackService.this.open(list, position);
        }
        public int getQueuePosition() {
            return MediaPlaybackService.this.getQueuePosition();
        }
        public void setQueuePosition(int index) {
            MediaPlaybackService.this.setQueuePosition(index);
        }
        public boolean isPlaying() {
            return MediaPlaybackService.this.isPlaying();
        }
        public void stop() {
            MediaPlaybackService.this.stop();
        }
        public void pause() {
            MediaPlaybackService.this.pause();
        }
        public void play() {
            MediaPlaybackService.this.play();
        }
        public void prev() {
            MediaPlaybackService.this.prev();
        }
        public void next() {
            MediaPlaybackService.this.next(true);
        }
        public String getTrackName() {
            return MediaPlaybackService.this.getTrackName();
        }
        public String getAlbumName() {
            return MediaPlaybackService.this.getAlbumName();
        }
        public int getAlbumId() {
            return MediaPlaybackService.this.getAlbumId();
        }
        public String getArtistName() {
            return MediaPlaybackService.this.getArtistName();
        }
        public int getArtistId() {
            return MediaPlaybackService.this.getArtistId();
        }
        public void enqueue(int [] list , int action) {
            MediaPlaybackService.this.enqueue(list, action);
        }
        public int [] getQueue() {
            return MediaPlaybackService.this.getQueue();
        }
        public void moveQueueItem(int from, int to) {
            MediaPlaybackService.this.moveQueueItem(from, to);
        }
        public String getPath() {
            return MediaPlaybackService.this.getPath();
        }
        public int getAudioId() {
            return MediaPlaybackService.this.getAudioId();
        }
        public long position() {
            return MediaPlaybackService.this.position();
        }
        public long duration() {
            return MediaPlaybackService.this.duration();
        }
        public long seek(long pos) {
            return MediaPlaybackService.this.seek(pos);
        }
        public void setShuffleMode(int shufflemode) {
            MediaPlaybackService.this.setShuffleMode(shufflemode);
        }
        public int getShuffleMode() {
            return MediaPlaybackService.this.getShuffleMode();
        }
        public int removeTracks(int first, int last) {
            return MediaPlaybackService.this.removeTracks(first, last);
        }
        public int removeTrack(int id) {
            return MediaPlaybackService.this.removeTrack(id);
        }
        public void setRepeatMode(int repeatmode) {
            MediaPlaybackService.this.setRepeatMode(repeatmode);
        }
        public int getRepeatMode() {
            return MediaPlaybackService.this.getRepeatMode();
        }
        public int getMediaMountedCount() {
            return MediaPlaybackService.this.getMediaMountedCount();
        }
    };
}