android实现背景音乐播放

package com.liu.zhen.utils;

import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.media.MediaPlayer;
import android.util.Log;

/**
 * 
 * This class is used for controlling background music
 * 
 */
public class BackgroundMusic {
	private static BackgroundMusic backgroundMusic = null;
	private static final String TAG = "Bg_Music";
	private float mLeftVolume;
	private float mRightVolume;
	private Context mContext;
	private MediaPlayer mBackgroundMediaPlayer;
	private boolean mIsPaused;
	private String mCurrentPath;

	private BackgroundMusic(Context context) {
		this.mContext = context;
		initData();
	}

	public static BackgroundMusic getInstance(Context context) {
		if (backgroundMusic == null) {
			backgroundMusic = new BackgroundMusic(context);
		}
		return backgroundMusic;
	}

	// 初始化一些数据
	private void initData() {
		mLeftVolume = 0.5f;
		mRightVolume = 0.5f;
		mBackgroundMediaPlayer = null;
		mIsPaused = false;
		mCurrentPath = null;
	}

	/**
	 * 根据path路径播放背景音乐
	 * 
	 * @param path
	 *            :assets中的音频路径
	 * @param isLoop
	 *            :是否循环播放
	 */
	public void playBackgroundMusic(String path, boolean isLoop) {
		if (mCurrentPath == null) {
			// 这是第一次播放背景音乐--- it is the first time to play background music
			// 或者是执行end()方法后，重新被叫---or end() was called
			mBackgroundMediaPlayer = createMediaplayerFromAssets(path);
			mCurrentPath = path;
		} else {
			if (!mCurrentPath.equals(path)) {
				// 播放一个新的背景音乐--- play new background music
				// 释放旧的资源并生成一个新的----release old resource and create a new one
				if (mBackgroundMediaPlayer != null) {
					mBackgroundMediaPlayer.release();
				}
				mBackgroundMediaPlayer = createMediaplayerFromAssets(path);
				// 记录这个路径---record the path
				mCurrentPath = path;
			}
		}

		if (mBackgroundMediaPlayer == null) {
			Log.e(TAG, "playBackgroundMusic: background media player is null");
		} else {
			// 若果音乐正在播放或已近中断，停止它---if the music is playing or paused, stop it
			mBackgroundMediaPlayer.stop();
			mBackgroundMediaPlayer.setLooping(isLoop);
			try {
				mBackgroundMediaPlayer.prepare();
				mBackgroundMediaPlayer.seekTo(0);
				mBackgroundMediaPlayer.start();
				this.mIsPaused = false;
			} catch (Exception e) {
				Log.e(TAG, "playBackgroundMusic: error state");
			}
		}
	}

	/**
	 * 停止播放背景音乐
	 */
	public void stopBackgroundMusic() {
		if (mBackgroundMediaPlayer != null) {
			mBackgroundMediaPlayer.stop();
			// should set the state, if not , the following sequence will be
			// error
			// play -> pause -> stop -> resume
			this.mIsPaused = false;
		}
	}

	/**
	 * 暂停播放背景音乐
	 */
	public void pauseBackgroundMusic() {
		if (mBackgroundMediaPlayer != null
				&& mBackgroundMediaPlayer.isPlaying()) {
			mBackgroundMediaPlayer.pause();
			this.mIsPaused = true;
		}
	}

	/**
	 * 继续播放背景音乐
	 */
	public void resumeBackgroundMusic() {
		if (mBackgroundMediaPlayer != null && this.mIsPaused) {
			mBackgroundMediaPlayer.start();
			this.mIsPaused = false;
		}
	}

	/**
	 * 重新播放背景音乐
	 */
	public void rewindBackgroundMusic() {
		if (mBackgroundMediaPlayer != null) {
			mBackgroundMediaPlayer.stop();
			try {
				mBackgroundMediaPlayer.prepare();
				mBackgroundMediaPlayer.seekTo(0);
				mBackgroundMediaPlayer.start();
				this.mIsPaused = false;
			} catch (Exception e) {
				Log.e(TAG, "rewindBackgroundMusic: error state");
			}
		}
	}

	/**
	 * 判断背景音乐是否正在播放
	 * 
	 * @return：返回的boolean值代表是否正在播放
	 */
	public boolean isBackgroundMusicPlaying() {
		boolean ret = false;
		if (mBackgroundMediaPlayer == null) {
			ret = false;
		} else {
			ret = mBackgroundMediaPlayer.isPlaying();
		}
		return ret;
	}

	/**
	 * 结束背景音乐，并释放资源
	 */
	public void end() {
		if (mBackgroundMediaPlayer != null) {
			mBackgroundMediaPlayer.release();
		}
		// 重新“初始化数据”
		initData();
	}

	/**
	 * 得到背景音乐的“音量”
	 * 
	 * @return
	 */
	public float getBackgroundVolume() {
		if (this.mBackgroundMediaPlayer != null) {
			return (this.mLeftVolume + this.mRightVolume) / 2;
		} else {
			return 0.0f;
		}
	}

	/**
	 * 设置背景音乐的音量
	 * 
	 * @param volume
	 *            ：设置播放的音量，float类型
	 */
	public void setBackgroundVolume(float volume) {
		this.mLeftVolume = this.mRightVolume = volume;
		if (this.mBackgroundMediaPlayer != null) {
			this.mBackgroundMediaPlayer.setVolume(this.mLeftVolume,
					this.mRightVolume);
		}
	}

	/**
	 * create mediaplayer for music
	 * 
	 * @param path
	 *            the path relative to assets
	 * @return
	 */
	private MediaPlayer createMediaplayerFromAssets(String path) {
		MediaPlayer mediaPlayer = null;
		try {
			AssetFileDescriptor assetFileDescritor = mContext.getAssets()
					.openFd(path);
			mediaPlayer = new MediaPlayer();
			mediaPlayer.setDataSource(assetFileDescritor.getFileDescriptor(),
					assetFileDescritor.getStartOffset(),
					assetFileDescritor.getLength());
			mediaPlayer.prepare();
			mediaPlayer.setVolume(mLeftVolume, mRightVolume);
		} catch (Exception e) {
			mediaPlayer = null;
			Log.e(TAG, "error: " + e.getMessage(), e);
		}
		return mediaPlayer;
	}
}