android实现背景音乐播放功能

参考了一下网上别人写的，再使用的时候是放在新开的线程中来播放音乐的，后来发现每次进入Activity后就会重复开始一个音乐播放的声音。为了避免重复开启播放功能我在原来代码的基础上增加了单例模式。这样就避免了出现重复播放。

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;
 }
}

来源：https://blog.csdn.net/liu1164316159/article/details/40400529