MusicPlayer.java

package com.tadpolemusic.media;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import com.tadpolemusic.TMLog;
import com.tadpolemusic.media.http.HttpGetProxy;

import android.content.Context;
import android.content.Intent;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnBufferingUpdateListener;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnErrorListener;
import android.os.Bundle;
import android.util.Log;

public class MusicPlayer implements OnCompletionListener, OnErrorListener, OnBufferingUpdateListener {

    public static final String BROCAST_NAME = "com.tadpolemusic.media.brocast";

    private final static String TAG = "MusicPlayer";

    private MediaPlayer mMediaPlayer;					// ���������

    private List<MusicData> mMusicFileList;				// �����ļ��б�

    private int mCurPlayIndex;							// ��ǰ��������

    private int mPlayState;         					// ������״̬	

    private int mPLayMode;								// �����ģʽ

    private Random mRandom;

    private Context mContext;

    private HttpGetProxy mHttpGetProxy;

    private int mCurBufferPercent = 100;
    private int mLastBufferPercent = 100;

    private void defaultParam() {
        mMediaPlayer = new MediaPlayer();

        mMediaPlayer.setOnCompletionListener(this);

        mMediaPlayer.setOnErrorListener(this);

        mMediaPlayer.setOnBufferingUpdateListener(this);

        mMusicFileList = new ArrayList<MusicData>();

        mCurPlayIndex = -1;

        mPlayState = MusicPlayState.MPS_NOFILE;

        mPLayMode = MusicPlayMode.MPM_LIST_LOOP_PLAY;

        mHttpGetProxy = new HttpGetProxy(9090);

        mHttpGetProxy.start();

    }

    public MusicPlayer(Context context) {
        mContext = context;
        defaultParam();

        mRandom = new Random();
        mRandom.setSeed(System.currentTimeMillis());
    }

    public void exit() {
        Log.d(TAG, "exit");
        mMediaPlayer.reset();
        mMusicFileList.clear();
        mCurPlayIndex = -1;
        mPlayState = MusicPlayState.MPS_NOFILE;
    }

    /**
     * @param playListID
     *            unique id .
     * @param FileList
     */
    public void refreshMusicList(String playListID, List<MusicData> FileList) {
        if (FileList == null) {
            mMusicFileList.clear();
            mPlayState = MusicPlayState.MPS_NOFILE;
            mCurPlayIndex = -1;

            mMediaPlayer.reset();
            sendPlayStateBrocast();

            return;
        }

        mMusicFileList = FileList;

        if (mMusicFileList.size() == 0) {
            mPlayState = MusicPlayState.MPS_NOFILE;
            mCurPlayIndex = -1;
            return;
        }

        curPlayListID = playListID;

        mPlayState = MusicPlayState.MPS_HAS_FILE;

        switch (mPlayState) {
        case MusicPlayState.MPS_NOFILE:
            //			prepare(0);
            break;
        case MusicPlayState.MPS_INVALID:
            //			prepare(0);
            break;
        case MusicPlayState.MPS_PREPARE:
            //			prepare(0);
            break;
        case MusicPlayState.MPS_PLAYING:
            break;
        case MusicPlayState.MPS_PAUSE:
            break;
        default:
            break;
        }
    }

    public List<MusicData> getFileList() {
        Log.i(TAG, "getFileList	mMusicFileList.size = " + mMusicFileList.size());
        return mMusicFileList;
    }

    public int getPlayState() {
        return mPlayState;
    }


    public boolean replay() {

        if (mPlayState == MusicPlayState.MPS_NOFILE || mPlayState == MusicPlayState.MPS_INVALID) {
            return false;
        }

        mMediaPlayer.start();
        mPlayState = MusicPlayState.MPS_PLAYING;
        sendPlayStateBrocast();

        return true;
    }

    public boolean play(int position) {
        if (mPlayState == MusicPlayState.MPS_NOFILE) {
            return false;
        }

        if (mCurPlayIndex == position) {
            if (mMediaPlayer.isPlaying() == false) {
                mMediaPlayer.start();
                mPlayState = MusicPlayState.MPS_PLAYING;
                sendPlayStateBrocast();
            }

            return true;
        }

        mCurPlayIndex = position;
        if (prepare(mCurPlayIndex) == false) {
            return false;
        }

        return replay();

    }

    public boolean pause() {
        if (mPlayState != MusicPlayState.MPS_PLAYING) {
            return false;
        }

        mMediaPlayer.pause();
        mPlayState = MusicPlayState.MPS_PAUSE;
        sendPlayStateBrocast();

        return true;
    }

    public boolean stop() {
        if (mPlayState != MusicPlayState.MPS_PLAYING && mPlayState != MusicPlayState.MPS_PAUSE) {
            return false;
        }


        return prepare(mCurPlayIndex);

    }

    public boolean playNext() {
        if (mPlayState == MusicPlayState.MPS_NOFILE) {
            return false;
        }


        mCurPlayIndex++;
        mCurPlayIndex = reviceIndex(mCurPlayIndex);


        if (prepare(mCurPlayIndex) == false) {
            return false;
        }

        return replay();
    }

    public boolean playPre() {
        if (mPlayState == MusicPlayState.MPS_NOFILE) {
            return false;
        }


        mCurPlayIndex--;
        mCurPlayIndex = reviceIndex(mCurPlayIndex);


        if (prepare(mCurPlayIndex) == false) {
            return false;
        }

        return replay();
    }

    public boolean seekTo(int rate) {
        if (mPlayState == MusicPlayState.MPS_NOFILE || mPlayState == MusicPlayState.MPS_INVALID) {
            return false;
        }

        int r = reviceSeekValue(rate);
        int time = mMediaPlayer.getDuration();
        int curTime = (int) ((float) r / 100 * time);

        mMediaPlayer.seekTo(curTime);
        return true;
    }

    public int getCurPosition() {
        if (mPlayState == MusicPlayState.MPS_PLAYING || mPlayState == MusicPlayState.MPS_PAUSE) {
            return mMediaPlayer.getCurrentPosition();
        }

        return 0;
    }

    public int getDuration() {

        if (mPlayState == MusicPlayState.MPS_NOFILE || mPlayState == MusicPlayState.MPS_INVALID) {
            return 0;
        }

        return mMediaPlayer.getDuration();


    }


    public void setPlayMode(int mode) {
        switch (mode) {
        case MusicPlayMode.MPM_SINGLE_LOOP_PLAY:
        case MusicPlayMode.MPM_ORDER_PLAY:
        case MusicPlayMode.MPM_LIST_LOOP_PLAY:
        case MusicPlayMode.MPM_RANDOM_PLAY:
            mPLayMode = mode;
            break;
        }

    }

    public int getPlayMode() {
        return mPLayMode;
    }



    private int reviceIndex(int index) {
        if (index < 0) {
            index = mMusicFileList.size() - 1;
        }

        if (index >= mMusicFileList.size()) {
            index = 0;
        }

        return index;
    }

    private int reviceSeekValue(int value) {
        if (value < 0) {
            value = 0;
        }

        if (value > 100) {
            value = 100;
        }

        return value;
    }

    private int getRandomIndex() {
        int size = mMusicFileList.size();
        if (size == 0) {
            return -1;
        }
        return Math.abs(mRandom.nextInt() % size);
    }

    private boolean prepare(int index) {
        Log.i(TAG, "prepare index = " + index);
        mCurPlayIndex = index;
        mMediaPlayer.reset();

        String path = mMusicFileList.get(index).musicPath;
        try {
            mMediaPlayer.setDataSource(mHttpGetProxy.getProxyUrl(path));
            mMediaPlayer.prepare();
            mPlayState = MusicPlayState.MPS_PREPARE;
            Log.i(TAG, "mMediaPlayer.prepare	path = " + path);
            sendPlayStateBrocast();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            mPlayState = MusicPlayState.MPS_INVALID;
            sendPlayStateBrocast();
            return false;
        }

        return true;
    }

    @Override
    public void onCompletion(MediaPlayer mp) {
        // TODO Auto-generated method stub
        Log.i(TAG, "mPLayMode = " + mPLayMode);
        switch (mPLayMode) {
        case MusicPlayMode.MPM_SINGLE_LOOP_PLAY:
            play(mCurPlayIndex);
            break;
        case MusicPlayMode.MPM_ORDER_PLAY: {
            if (mCurPlayIndex != mMusicFileList.size() - 1) {
                playNext();
            } else {
                prepare(mCurPlayIndex);
            }
        }
            break;
        case MusicPlayMode.MPM_LIST_LOOP_PLAY:
            playNext();
            break;
        case MusicPlayMode.MPM_RANDOM_PLAY: {
            int index = getRandomIndex();
            if (index != -1) {
                mCurPlayIndex = index;
            } else {
                mCurPlayIndex++;
            }
            mCurPlayIndex = reviceIndex(mCurPlayIndex);


            if (prepare(mCurPlayIndex)) {
                replay();
            }
        }
            break;
        default:
            prepare(mCurPlayIndex);
            break;
        }
    }


    public void sendPlayStateBrocast() {
        if (mContext != null) {
            Intent intent = new Intent(BROCAST_NAME);
            intent.putExtra(MusicPlayState.PLAY_STATE_NAME, mPlayState);
            intent.putExtra(MusicPlayState.PLAY_MUSIC_INDEX, mCurPlayIndex);
            intent.putExtra(MusicPlayState.PLAY_BUFFER_PERCENT, mCurBufferPercent);

            if (mPlayState != MusicPlayState.MPS_NOFILE) {
                Bundle bundle = new Bundle();
                MusicData data = mMusicFileList.get(mCurPlayIndex);
                data.musicDuration = getDuration();
                intent.putExtra(MusicData.KEY_MUSIC_DATA, data);
            }

            mContext.sendBroadcast(intent);
        }


    }

    @Override
    public boolean onError(MediaPlayer mp, int what, int extra) {
        Log.e(TAG, "MusicPlayer		onError!!!\n");
        return false;
    }

    //------------------------------------------------------
    //
    //--------------------------------------------------


    private String curPlayListID = "";

    public PlayListInfo getCurPlayListInfo() {
        PlayListInfo info = new PlayListInfo();
        info.playListID = curPlayListID;
        if (mMusicFileList != null) {
            info.listSize = mMusicFileList.size();
            info.playingIndex = mCurPlayIndex;
        }
        return info;
    }

    public void getCurrentPlayListInfo(PlayListInfo info) {
        info.playListID = curPlayListID;
        if (mMusicFileList != null) {
            info.listSize = mMusicFileList.size();
        }
    }

    @Override
    public void onBufferingUpdate(MediaPlayer arg0, int percent) {
        TMLog.step(TAG, "onBufferingUpdate percent" + percent);
        mLastBufferPercent = mCurBufferPercent;
        mCurBufferPercent = percent;
        if (mCurBufferPercent != mLastBufferPercent) {
            sendPlayStateBrocast();
        }
        return;
    }
}