AudioRecorder.java

浏览该文件的文档.

package com.netease.nimlib.sdk.media.record;

import android.content.Context;
import android.media.AudioManager;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.text.TextUtils;

import com.netease.nimlib.SDKCache;
import com.netease.nimlib.log.NimLog;
import com.netease.nimlib.net.http.util.AttachmentStore;
import com.netease.nimlib.util.NetworkUtil;
import com.netease.nimlib.util.StringUtil;
import com.netease.nimlib.util.storage.NimStorageType;
import com.netease.nimlib.util.storage.NimStorageUtil;
import com.netease.share.media.AudioRecord;
import com.netease.share.media.OnInfoListener;

import java.io.File;
import java.util.concurrent.atomic.AtomicBoolean;

public class AudioRecorder {

    public static final int DEFAULT_MAX_AUDIO_RECORD_TIME_SECOND = 120;
    private static final int MSG_START_RECORD = 1;
    private static final int MSG_STOP_RECORD = 2;
    private static final int MSG_END_RECORD = 3; // 录音超时等异常结束

    private static final int RECORD_FAILED = 1;
    private static final int RECORD_READY = 2;
    private static final int RECORD_START = 3;
    private static final int RECORD_SUCCESS = 4;
    private static final int RECORD_CANCELED = 5;
    private static final String TAG = "AudioRecordManager";

    private AudioRecord mAudioRecorder;
    private AudioManager audioManager;

    private Context context;
    private int networkClass = NetworkUtil.NETWORK_CLASS_UNKNOWN;

    private File audioFile;
    private RecordType recordType;
    private int maxDuration;
    private AtomicBoolean isRecording = new AtomicBoolean(false);
    private AtomicBoolean cancelRecord = new AtomicBoolean(false);
    private IAudioRecordCallback cb;

    private RecordHandler mHandler;
    private Handler mEventHandler = new Handler(Looper.getMainLooper());
    private HandlerThread handlerThread;

    private class RecordHandler extends Handler {

        public RecordHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_START_RECORD:
                    onStartRecord();
                    break;
                case MSG_STOP_RECORD:
                    boolean cancel = (Boolean) msg.obj;
                    onCompleteRecord(cancel);
                    break;
                case MSG_END_RECORD:
                    boolean success = (Boolean) msg.obj;
                    int duration = msg.arg1;
                    onHandleEndRecord(success, duration);
                    break;
            }
        }
    }

    public AudioRecorder(
            Context context,
            RecordType recordType,
            int maxDuration,
            IAudioRecordCallback cb
    ) {
        this.context = context.getApplicationContext();
        this.recordType = recordType;
        if (maxDuration <= 0) {
            this.maxDuration = DEFAULT_MAX_AUDIO_RECORD_TIME_SECOND;
        } else {
            this.maxDuration = maxDuration;
        }
        this.cb = cb;

        audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
        handlerThread = new HandlerThread("audio_recorder");
        handlerThread.start();
        mHandler = new RecordHandler(handlerThread.getLooper());
    }

    public void startRecord() {
        // 移除队列中的 开始任务
        mHandler.removeMessages(MSG_START_RECORD);
        mHandler.obtainMessage(MSG_START_RECORD).sendToTarget();
    }

    private void onStartRecord() {
        audioManager.requestAudioFocus(null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);

        if (isRecording.get()) {
            NimLog.audio(TAG + " startRecord false, as current state is isRecording");
            callBackRecordState(RECORD_FAILED);
            return;
        }

        if (!NimStorageUtil.hasEnoughSpaceForWrite(NimStorageType.TYPE_AUDIO)) {
            NimLog.audio(TAG + " startRecord false, as has no enough space to write");
            callBackRecordState(RECORD_FAILED);
            return;
        }

        int outputFormat = recordType.getOutputFormat();

        String outputFilePath = NimStorageUtil.getWritePath(SDKCache.getContext(), StringUtil.get36UUID() + outputFormat,
                NimStorageType.TYPE_AUDIO);
        if (TextUtils.isEmpty(outputFilePath)) {
            NimLog.audio(TAG + " startRecord false, as outputFilePath is empty");
            callBackRecordState(RECORD_FAILED);
            return;
        } else {
            outputFilePath = outputFilePath + recordType.getFileSuffix();
            audioFile = new File(outputFilePath);
        }

        cancelRecord.set(false);

        try {
            mAudioRecorder = new AudioRecord(context, outputFilePath, maxDuration * 1000);
            mAudioRecorder.setAudioCodec(outputFormat);
            networkClass = NetworkUtil.getNetworkClass(context);
            if (networkClass == NetworkUtil.NETWORK_CLASS_3_G)
                mAudioRecorder.setMaxSampleRateInHz(22050);
            else if (networkClass == NetworkUtil.NETWORK_CLASS_2_G)
                mAudioRecorder.setMaxSampleRateInHz(16000);
            mAudioRecorder.setOnInfoListener(infoListener);

            if (!cancelRecord.get()) {
                callBackRecordState(RECORD_READY);
                if (mAudioRecorder.startRecording()) {
                    isRecording.set(true);
                    callBackRecordState(RECORD_START);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            onCompleteRecord(false);
        }
        if (!isRecording.get()) {
            callBackRecordState(RECORD_FAILED);
        }
    }

    public void completeRecord(boolean cancel) {
        Message message = mHandler.obtainMessage(MSG_STOP_RECORD);
        message.obj = cancel;
        message.sendToTarget();
    }

    private void onCompleteRecord(boolean cancel) {
        if (!isRecording.get()) {
            return;
        }
        cancelRecord.set(cancel);
        audioManager.abandonAudioFocus(null);
        try {
            if (mAudioRecorder != null) {
                mAudioRecorder.stopRecording();
                onHandleEndRecord(true, mAudioRecorder.duration());
                mAudioRecorder = null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void destroyAudioRecorder() {
        if (mHandler != null) {
            mHandler.removeCallbacksAndMessages(null);
        }
        if (handlerThread != null && handlerThread.isAlive()) {
            Looper looper = handlerThread.getLooper();
            looper.quit();
        }
    }

    public boolean isRecording() {
        return isRecording.get();
    }

    public void handleEndRecord(boolean isSuccess, int duration) {
        Message message = mHandler.obtainMessage(MSG_END_RECORD);
        message.obj = isSuccess;
        message.arg1 = duration;
        message.sendToTarget();
    }

    private void onHandleEndRecord(boolean isSuccess, final int duration) {
        if (cancelRecord.get()) {
            // cancel
            AttachmentStore.deleteOnExit(audioFile.getAbsolutePath());

            callBackRecordState(RECORD_CANCELED);
        } else if (!isSuccess) {
            // failed
            AttachmentStore.deleteOnExit(audioFile.getAbsolutePath());
            callBackRecordState(RECORD_FAILED);
        } else {
            // error
            if (audioFile == null || !audioFile.exists() || audioFile.length() <= 0) {
                callBackRecordState(RECORD_FAILED);
            } else {
                // success
                mEventHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        cb.onRecordSuccess(audioFile, duration, recordType);
                    }
                });
            }
        }
        isRecording.set(false);
    }

    private void callBackRecordState(final int recordState) {
        mEventHandler.post(new Runnable() {
            @Override
            public void run() {
                switch (recordState) {
                    case RECORD_FAILED:
                        cb.onRecordFail();
                        break;
                    case RECORD_READY:
                        cb.onRecordReady();
                        break;
                    case RECORD_START:
                        cb.onRecordStart(audioFile, recordType);
                        break;
                    case RECORD_CANCELED:
                        cb.onRecordCancel();
                    default:
                        break;
                }
            }
        });
    }

    public int getCurrentRecordMaxAmplitude() {
        if (mAudioRecorder != null) {
            return mAudioRecorder.getMaxAmplitude();
        }

        return 0;
    }

    private void handleReachedMaxRecordTime(int duration) {
        cb.onRecordReachedMaxTime(duration);
    }

    // UI线程回调
    private OnInfoListener infoListener = new OnInfoListener() {

        @Override
        public void onInfo(int session, int what, int extra) {
            if (what == OnInfoListener.MEDIA_RECORDER_INFO_ERROR) {
                handleEndRecord(false, 0);
            } else if (what == OnInfoListener.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        isRecording.set(false);
                    }
                });
                handleReachedMaxRecordTime(extra);
            } else if (what == OnInfoListener.MEDIA_RECORDER_INFO_STARTED) {
                //

            }
        }
    };

}