AudioRecoder 录音

packagecom.ldm.mediarecorder.activity;

importandroid.Manifest;

importandroid.content.pm.PackageManager;

importandroid.media.AudioFormat;

importandroid.media.AudioManager;

importandroid.media.AudioRecord;

importandroid.media.AudioTrack;

importandroid.media.MediaRecorder;

importandroid.os.AsyncTask;

importandroid.os.Build;

importandroid.os.Environment;

importandroid.os.Handler;

importandroid.os.Message;

importandroid.support.annotation.NonNull;

importandroid.support.v4.app.ActivityCompat;

importandroid.support.v4.content.ContextCompat;

importandroid.util.Log;

importandroid.view.View;

importandroid.widget.AdapterView;

importandroid.widget.Button;

importandroid.widget.ListView;

importandroid.widget.Toast;

importcom.ldm.mediarecorder.R;

importcom.ldm.mediarecorder.adapter.AudioAdapter;

importcom.ldm.mediarecorder.base.BaseActivity;

importcom.ldm.mediarecorder.base.Constant;

importcom.ldm.mediarecorder.model.FileBean;

importjava.io.BufferedInputStream;

importjava.io.DataInputStream;

importjava.io.File;

importjava.io.FileInputStream;

importjava.io.FileOutputStream;

importjava.io.IOException;

importjava.util.ArrayList;

importjava.util.List;

importjava.util.concurrent.ExecutorService;

importjava.util.concurrent.Executors;

/**

* 该实例中，我们使用AudioRecord类来完成我们的音频录制程序

* AudioRecord类，我们可以使用三种不同的read方法来完成录制工作，

* 每种方法都有其实用的场合

* 一、实例化一个AudioRecord类我们需要传入几种参数

* 1、AudioSource：这里可以是MediaRecorder.AudioSource.MIC

* 2、SampleRateInHz:录制频率，可以为8000hz或者11025hz等，不同的硬件设备这个值不同

* 3、ChannelConfig:录制通道，可以为AudioFormat.CHANNEL_CONFIGURATION_MONO和AudioFormat.CHANNEL_CONFIGURATION_STEREO

* 4、AudioFormat:录制编码格式，可以为AudioFormat.ENCODING_16BIT和8BIT,其中16BIT的仿真性比8BIT好，但是需要消耗更多的电量和存储空间

* 5、BufferSize:录制缓冲大小：可以通过getMinBufferSize来获取

* 这样我们就可以实例化一个AudioRecord对象了

* 二、创建一个文件，用于保存录制的内容

* 同上篇

* 三、打开一个输出流，指向创建的文件

* DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)))

* 四、现在就可以开始录制了，我们需要创建一个字节数组来存储从AudioRecorder中返回的音频数据，但是

* 注意，我们定义的数组要小于定义AudioRecord时指定的那个BufferSize

* short[]buffer = new short[BufferSize/4];

* startRecording();

* 然后一个循环，调用AudioRecord的read方法实现读取

* 另外使用MediaPlayer是无法播放使用AudioRecord录制的音频的，为了实现播放，我们需要

* 使用AudioTrack类来实现

* AudioTrack类允许我们播放原始的音频数据

*

*

* 一、实例化一个AudioTrack同样要传入几个参数

* 1、StreamType:在AudioManager中有几个常量，其中一个是STREAM_MUSIC;

* 2、SampleRateInHz：最好和AudioRecord使用的是同一个值

* 3、ChannelConfig：同上

* 4、AudioFormat：同上

* 5、BufferSize：通过AudioTrack的静态方法getMinBufferSize来获取

* 6、Mode：可以是AudioTrack.MODE_STREAM和MODE_STATIC，关于这两种不同之处，可以查阅文档

* 二、打开一个输入流，指向刚刚录制内容保存的文件，然后开始播放，边读取边播放

*

* 实现时，音频的录制和播放分别使用两个AsyncTask来完成

*/

public classAudioRecordActivityextendsBaseActivity {

privatePlayTaskplayer;

privateButtonstart_tv;

privateListViewlistView;

//线程操作

privateExecutorServicemExecutorService;

//当前是否正在录音

private volatile booleanisRecording;

//录音开始时间与结束时间

private longstartTime,endTime;

//录音所保存的文件

privateFilemAudioFile;

/**

* 文件列表数据

*/

privateListdataList;

privateAudioAdaptermAudioAdapter;

//private String mFilePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/audio/";

privateStringmFilePath= Environment.getExternalStorageDirectory().getAbsolutePath()+"/zhangxinaaaaa/";

private byte[]mBuffer;

privateFileOutputStreammFileOutPutStream;

//文件流录音API

privateAudioRecordmAudioRecord;

private volatile booleanisPlaying;

/**

* 配置AudioRecord

*/

private final intaudioSource= MediaRecorder.AudioSource.MIC;

private intfrequence=8000;//录制频率，单位hz.这里的值注意了，写的不好，可能实例化AudioRecord对象的时候，会出错。我开始写成11025就不行。这取决于硬件设备

private intchannelConfig= AudioFormat.CHANNEL_CONFIGURATION_MONO;

private intaudioEncoding= AudioFormat.ENCODING_PCM_16BIT;

//缓存大小

private static final intBUFFER_SIZE=2048;

//计算AudioRecord内部buffer大小

private final intminBufferSize= AudioRecord.getMinBufferSize(frequence,channelConfig,audioEncoding);

//更新UI线程的Handler

privateHandlermHandler=newHandler() {

@Override

public voidhandleMessage(Message msg) {

super.handleMessage(msg);

switch(msg.what) {

caseConstant.RECORD_SUCCESS:

//录音成功，展示数据

if(null==mAudioAdapter) {

mAudioAdapter=newAudioAdapter(AudioRecordActivity.this,dataList,R.layout.file_item_layout);

}

listView.setAdapter(mAudioAdapter);

break;

//录音失败

caseConstant.RECORD_FAIL:

showToastMsg(getString(R.string.record_fail));

break;

//录音时间太短

caseConstant.RECORD_TOO_SHORT:

showToastMsg(getString(R.string.time_too_short));

break;

caseConstant.PLAY_COMPLETION:

showToastMsg(getString(R.string.play_over));

break;

caseConstant.PLAY_ERROR:

showToastMsg(getString(R.string.play_error));

break;

}

}

};

@Override

protected voidsetWindowView() {

setContentView(R.layout.activity_record);

dataList=newArrayList<>();

mExecutorService= Executors.newSingleThreadExecutor();

mBuffer=new byte[BUFFER_SIZE];

}

@Override

protected voidinitViews() {

this.start_tv= (Button) findViewById(R.id.start_tv);

this.listView= (ListView) findViewById(R.id.listview);

}

@Override

protected voidinitEvents() {

this.start_tv.setOnClickListener(this);

//点击Item播放对应的声音文件

this.listView.setOnItemClickListener(newAdapterView.OnItemClickListener() {

@Override

public voidonItemClick(AdapterView adapterView,View view, inti, longl) {

//使用AudioTrack播放声音流文件

Toast.makeText(AudioRecordActivity.this,i +"",Toast.LENGTH_SHORT).show();

player=newPlayTask(dataList.get(i).getFile());

player.execute();

}

});

}

@Override

public voidonClick(View view) {

switch(view.getId()) {

//开始录音操作

caseR.id.start_tv:

//正在录音

if(isRecording) {

isRecording=false;

start_tv.setText(R.string.start_record);

//停止录音

mExecutorService.submit(newRunnable() {

@Override

public voidrun() {

stopRecord();

}

});

}else{

isRecording=true;

start_tv.setText(R.string.stop_record);

//录音操作

mExecutorService.submit(newRunnable() {

@Override

public voidrun() {

if(Build.VERSION.SDK_INT>22) {

//6.0以上权限管理

permissionForM();

}else{

//开始录音

startRecord();

}

}

});

}

break;

}

}

/**

* 开始录制

*/

private voidstartRecord() {

try{

//创建录音文件,.m4a为MPEG-4音频标准的文件的扩展名

mAudioFile=newFile(mFilePath+ System.currentTimeMillis() +".pcm");

//创建父文件夹

mAudioFile.getParentFile().mkdirs();

//创建文件

mAudioFile.createNewFile();

//创建文件输出流

mFileOutPutStream=newFileOutputStream(mAudioFile);

//根据上面的设置参数初始化AudioRecord

mAudioRecord=newAudioRecord(audioSource,frequence,channelConfig,audioEncoding,Math.max(minBufferSize,BUFFER_SIZE));

//开始录音

mAudioRecord.startRecording();

//记录开始时间

startTime= System.currentTimeMillis();

short[] buffer =new short[BUFFER_SIZE];

while(isRecording) {

//r是实际读取的数据长度，一般而言r会小于buffersize

intr =mAudioRecord.read(buffer,0,BUFFER_SIZE);

longv =0;

// 将 buffer 内容取出，进行平方和运算

for(inti =0;i < buffer.length;i++) {

v += buffer[i] * buffer[i];

}

// 平方和除以数据总长度，得到音量大小。

doublemean = v / (double) r;

doublevolume =10* Math.log10(mean);

Log.d("zhangxin","分贝值:"+ volume);

}

//写入数据到文件

while(isRecording) {

intread =mAudioRecord.read(mBuffer,0,BUFFER_SIZE);

if(read >0) {

//保存到指定文件

mFileOutPutStream.write(mBuffer,0,read);

}

}

}catch(IOException e) {

mHandler.sendEmptyMessage(Constant.RECORD_FAIL);

}finally{

//            if (null != mAudioRecord) {

//                //释放资源

//                mAudioRecord.release();

//            }

}

}

/**

*@description停止录音

*

*/

private voidstopRecord() {

try{

//停止录音

mAudioRecord.stop();

mAudioRecord.release();

mAudioRecord=null;

mFileOutPutStream.close();

//记录时长

endTime= System.currentTimeMillis();

//录音时间处理，比如只有大于2秒的录音才算成功

inttime = (int) ((endTime-startTime) /1000);

if(time >=3) {

//录音成功,添加数据

FileBean bean =newFileBean();

bean.setFile(mAudioFile);

bean.setFileLength(time);

dataList.add(bean);

//录音成功,发Message

mHandler.sendEmptyMessage(Constant.RECORD_SUCCESS);

}else{

mAudioFile=null;

mHandler.sendEmptyMessage(Constant.RECORD_TOO_SHORT);

}

}catch(Exception e) {

mHandler.sendEmptyMessage(Constant.RECORD_FAIL);

}

}

@Override

protected voidonDestroy() {

super.onDestroy();

if(null!=mExecutorService) {

mExecutorService.shutdownNow();

}

}

/**

* 6.0以上版本手机权限处理

*/

private voidpermissionForM() {

if(ContextCompat.checkSelfPermission(this,

Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED|| ContextCompat.checkSelfPermission(this,

Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {

ActivityCompat.requestPermissions(this,

newString[]{Manifest.permission.RECORD_AUDIO,Manifest.permission.WRITE_EXTERNAL_STORAGE},

Constant.PERMISSIONS_REQUEST_FOR_AUDIO);

}else{

startRecord();

}

}

@Override

public voidonRequestPermissionsResult(intrequestCode,@NonNullString[] permissions,@NonNullint[] grantResults) {

if(requestCode == Constant.PERMISSIONS_REQUEST_FOR_AUDIO) {

if(grantResults[0] == PackageManager.PERMISSION_GRANTED) {

startRecord();

}

return;

}

super.onRequestPermissionsResult(requestCode,permissions,grantResults);

}

/**

* 播放音频

*/

public classPlayTaskextendsAsyncTask {

FileaudioFile;

publicPlayTask(File audioFile) {

this.audioFile= audioFile;

}

@Override

protectedVoiddoInBackground(Void... arg0) {

isPlaying=true;

intbufferSize = AudioTrack.getMinBufferSize(frequence,channelConfig,audioEncoding);

short[] buffer =new short[bufferSize /4];

try{

//定义输入流，将音频写入到AudioTrack类中，实现播放

DataInputStream dis =newDataInputStream(newBufferedInputStream(newFileInputStream(audioFile)));

//实例AudioTrack

AudioTrack track =newAudioTrack(AudioManager.STREAM_MUSIC,frequence,channelConfig,audioEncoding,bufferSize,AudioTrack.MODE_STREAM);

//开始播放

track.play();

//由于AudioTrack播放的是流，所以，我们需要一边播放一边读取

while(isPlaying&& dis.available() >0) {

inti =0;

while(dis.available() >0&& i < buffer.length) {

buffer[i] = dis.readShort();

i++;

}

//然后将数据写入到AudioTrack中

track.write(buffer,0,buffer.length);

}

//播放结束

track.stop();

dis.close();

}catch(Exception e) {

//TODO: handle exception

}

return null;

}

}

}