Android录音播放工具类，仿微信语音聊天。

代码是从聊天类项目中抽出来的，播放类中含有本地播放和网络播放，做法仿微信，先将网络路径中的.amr文件下载下来，然后存到本地播放。
一、录音类

import java.io.File;
import java.io.IOException;

import android.media.MediaRecorder;

public class ChatRecorder {

    private String mOutputFileName = "";
    private MediaRecorder mRecorder = null;
    private long mStartTime = 0L;
    private static ChatRecorder mChatRecorder = null;

    private ChatRecorder() {}

    public static ChatRecorder getInstance() {
        if (mChatRecorder == null) {
            synchronized (ChatRecorder.class) {
                if (mChatRecorder == null) {
                    mChatRecorder = new ChatRecorder();
                }
            }
        }
        return mChatRecorder;
    }

    public void initRecorder() {
        mRecorder = new MediaRecorder();
    }

    public void startRecord(String outputFileName) {
        if (mRecorder == null) {
            return;
        }
        this.mOutputFileName = outputFileName;
        File parentFile = new File(outputFileName).getParentFile();
        if (!parentFile.exists()) {
            parentFile.mkdirs();
        }
        mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        mRecorder.setOutputFormat(MediaRecorder.OutputFormat.AMR_NB);
        mRecorder.setOutputFile(mOutputFileName);
        mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        try {
            mRecorder.prepare();
        } catch (IOException e) {
            e.printStackTrace();
        }
        mRecorder.start();
        mStartTime = System.currentTimeMillis();
    }


    public long stopRecord() {
        if (mRecorder != null) {
            mRecorder.stop();
            return System.currentTimeMillis() - mStartTime;
        }
        return 0L;
    }

    public void exitRecorder() {
        if (mRecorder != null) {
            mRecorder.release();
            mRecorder = null;
        }
    }

    public String getOutputFileName() {
        return mOutputFileName;
    }

    public double getAmplitude() {
        if (mRecorder != null) {
            return (mRecorder.getMaxAmplitude() / 2700.0);
        } else {
            return 0;
        }
    }
}

二、播放类

package net.bangbao.im.imkit.base;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;

import net.bangbao.R;
import net.bangbao.XConfig;
import net.bangbao.XManager;
import net.bangbao.utils.EncryptionUtils;
import net.bangbao.utils.FileUtil;
import net.bangbao.utils.UIUtils;
import net.bangbao.utils.Utils;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnErrorListener;
import android.net.Uri;
import android.os.Handler;
import android.os.Handler.Callback;
import android.os.Message;

public class ChatPlayer {
    private static final String TAG = ChatPlayer.class.getSimpleName();
    private static final int MSG_WHAT_PLAY = 1000;
    private static ChatPlayer mChatPlayer = null;
    private MediaPlayer mPlayer = null;
    private String mCurrentUrl = "";
    private OnMediaPlayListener mMediaPlayListener = null;
    private Handler mHandler = null;
    Callback downloadCallback = new Callback() {

        @Override
        public boolean handleMessage(Message msg) {
            if (msg.what == MSG_WHAT_PLAY) {
                if (msg.obj instanceof File) {
                    File localFile = (File) msg.obj;
                    playFromLocal(localFile);
                }
            }
            return false;
        }
    };

    private ChatPlayer() {}

    public static ChatPlayer getInstance() {
        if (mChatPlayer == null) {
            synchronized (ChatPlayer.class) {
                if (mChatPlayer == null) {
                    mChatPlayer = new ChatPlayer();
                }
            }
        }
        return mChatPlayer;
    }

    public interface OnMediaPlayListener {

        void onStart(String url);

        void onCompletion(String url);

        void onError(String url);
    }

    public void init() {
        mPlayer = new MediaPlayer();
        mHandler = new Handler(downloadCallback);
    }

    public void play(final String url, final OnMediaPlayListener listener) {
        if (mPlayer == null) {
            return;
        }
        if (mPlayer.isPlaying()) {
            mPlayer.stop();
            if (mMediaPlayListener != null) {
                mMediaPlayListener.onCompletion(mCurrentUrl);
            }
        }
        mCurrentUrl = url;
        mMediaPlayListener = listener;
        mPlayer.setOnCompletionListener(new OnCompletionListener() {

            @Override
            public void onCompletion(MediaPlayer mp) {
                if (mMediaPlayListener != null) {
                    mMediaPlayListener.onCompletion(mCurrentUrl);
                }
            }
        });

        mPlayer.setOnErrorListener(new OnErrorListener() {

            @Override
            public boolean onError(MediaPlayer mp, int what, int extra) {
                if (mMediaPlayListener != null) {
                    listener.onError(mCurrentUrl);
                }
                return false;
            }
        });

        if (!FileUtil.isCanUseSDCard()) {
            UIUtils.toastMsgFromResource(XManager.getManager().getApplication(), R.string.sdcard_err);
            return;
        }

        String wholeUrl = Utils.getWholeUrl(mCurrentUrl, XConfig.FILE_SCHEME);
        if (wholeUrl.startsWith(XConfig.FILE_SCHEME)) {
            playFromLocal(wholeUrl);
            return;
        }

        File localDir = new File(XConfig.DIR_CHAT_VOICE_CACHE);
        if (!localDir.exists()) {
            localDir.mkdirs();
        }
        final File localFile = new File(localDir, mCurrentUrl + ".amr");
        if (localFile.exists()) {
            playFromLocal(localFile);
        } else {
            playFromNetwork(mCurrentUrl, localFile);
        }
    }

    public boolean isPlaying() {
        if (mPlayer == null) {
            return false;
        }
        return mPlayer.isPlaying();
    }

    public void stop() {
        if (mPlayer != null) {
            mPlayer.stop();
            if (mMediaPlayListener != null) {
                mMediaPlayListener.onCompletion(mCurrentUrl);
            }
        }
    }

    public void release() {
        if (mPlayer != null) {
            mPlayer.release();
            mPlayer = null;
            mHandler.removeMessages(MSG_WHAT_PLAY);
            if (mMediaPlayListener != null) {
                mMediaPlayListener.onCompletion(mCurrentUrl);
            }
        }
    }

    private void playFromNetwork(final String source, final File localFile) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                int count;
                try {
                    URL url = new URL(source);
                    URLConnection conn = url.openConnection();
                    conn.connect();

                    InputStream input = new BufferedInputStream(url.openStream());
                    OutputStream output = new FileOutputStream(localFile);

                    byte data[] = new byte[1024];

                    while ((count = input.read(data)) != -1) {
                        output.write(data, 0, count);
                    }
                    output.flush();
                    output.close();
                    input.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                Message msg = mHandler.obtainMessage();
                msg.what = MSG_WHAT_PLAY;
                msg.obj = localFile;
                mHandler.sendMessage(msg);

            }
        }).start();
    }

    private void playFromLocal(File localFile) {
        if (mPlayer == null) {
            return;
        }
        try {
            Uri uri = Uri.fromFile(localFile);
            mPlayer.reset();
            mPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
            mPlayer.setDataSource(XManager.getManager().getApplication(), uri);
            mPlayer.prepare();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        mPlayer.start();
        if (mMediaPlayListener != null) {
            mMediaPlayListener.onStart(mCurrentUrl);
        }
    }

    private void playFromLocal(String localFilePath) {
        if (mPlayer == null) {
            return;
        }
        try {
            mPlayer.reset();
            mPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
            mPlayer.setDataSource(localFilePath);
            mPlayer.prepare();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        mPlayer.start();
        if (mMediaPlayListener != null) {
            mMediaPlayListener.onStart(mCurrentUrl);
        }
    }
}