Android 实现能够暂停的录音功能

转载请注明出处：http://blog.csdn.net/yegongheng/article/details/40624267

      我们知道Android ApI提供了MediaRecorder和AudioRecord两个类给开发者来很方便地实现音视频的录制(前者可以实现音频和视频的录制，后者只能实现音频的录制)。这两个类都提供了start()和stop()方法用于开始和结束音频或视频的录制，但令人费解的是这两个类都没有提供pause()方法用于暂停录制音视频，因为在实际应用当中，暂停录制的功能是非常有必要的，暂不清楚Google工程师们在设计API时是如何考量的而没有添加这个方法，可能另有玄机吧。那既然Android自身没有提供这样一个方法，就只有我们自己来实现了，那么问题就来了，就是到底如何实现音频录制的暂停方法呢？别急，先讲一下我在工作中所遇到的需求，如下：需实现音频录制的暂停功能，并且生成的音频文件格式必须是m4a格式。为什么项目中音频文件一定要采用m4a格式的呢？有以下几点原因：

     1. 录制相同时间的音频，使用m4a格式存储的文件的大小要比使用其它格式类型存储的文件的大小要小(通过实验多次，在相同采样率16000的情况下，一般录制5分钟的音频，采用m4a格式存储的音频文件只有1.2Mb，而采用arm、mp3及其它格式的一般都有2-5Mb)，这样当用户需要下载或上传录制的音频文件时，可以节省流量，并且相同压缩率的前提下，m4a格式音频的音质相比其它格式的也更高；
     2.产品同时拥有Android客户端和IOS客户端，那为了避免使用Android客户端的用户录制的音频上传到服务器之后，使用IOS客户端的用户下载下来发生无法播放的问题，我们需统一录制音频的存储格式。由于Iphone手机官方推荐的音频格式是m4a且对m4a格式的音频文件支持度较高，再综合第一点来看，于是我们选择m4a格式作为音频文件的存储格式。

    好了，解释了为什么音频录制文件必须使用m4a存储格式之后，接下来我们来解决如何实现音频的录制的暂停功能。前面讲了，Android SDK API提供了MediaRecorder和AudioRecord两个类来完成音视频的录制方法，我们看下它们两者之间的特点和区别：

MediaRecorder:

  特性：该类集成了录音、编码和压缩等功能，可根据设置的编码格式的参数直接生成各种格式的音频文件(如arm、               mp3或m4a等)，由于集成度较高，因此使用起来简单，但灵活度不高，不能实现像AudioRecord那样进行音               频的实时处理。

AudioRecord:

  特性：该类录制的音频为原始的PCM二进制音频数据，没有文件头和文件尾，生成的PCM文件不能直接使用                         Mediaplayer播放，只能使用AudioTrack播放。使用AudioRecord可以实现边录边播的音频实时处理。

了解了这两个类的特性之后，起初我决定使用MediaRecorder类来解决录制暂停的问题，具体的思路如下：

      (1)每次触发开始录制和暂停录制音频的事件时都单独保存一个m4a格式的音频文件，直到最后触发停止录制音频的事件时，将之前录制的若干m4a格式的音频文件合并成一个文件。如图下：

      这种方法比较好理解，也容易想到，不过在实现过程中遇到了一个技术难点，那就是多个m4a格式的音频文件的合并并不是简单地将文件的内容拷贝到一个文件中，而是要通过分析每一个m4a格式的音频文件，计算出每个文件头的结构大小，并将文件头去掉，再将文件进行拷贝合并。通过查阅资料，发现m4a格式的音频文件头是由多个包含关系的ATOM结构组成，且每个不同的m4a格式的音频文件的文件头的大小都不一样，这样使得多个m4a文件头文件解析和合并变得较为复杂，若有多个m4a文件需要合并，那么会变得较为耗时。再者，对于没有足够音视频文件解析和编解码经验的开发者来讲，要精准地得解析一个m4a文件，挑战性太大(网上这方面的资料也寥寥无几),有兴趣的读者可以进行深入研究。

上述方法行不通，于是只好作罢，后来又想到了另外一种方法，也是我解决问题的最终方案，具体的思路如下：

     (2)由于使用AudioRecord类提供的方法录制的音频是原始的PCM格式的二进制数据，该格式的文件没有文件头信息，那么我们在进行文件合并时就就无需解析文件结构去掉对应的文件头，这样就变成了二进制数据地简单拷贝和合并。我在这里实现的方式是在录制音频的过程中采用边录制边写入的方式不断地向同一个文件写入录制的二进制音频数据。当触发暂停录音事件时，停止录制停止写入二进制数据，当触发继续录音事件时，则继续录制和向文件中写入数据。最后停止写入数据时，将PCM二进制音频文件编码成m4a格式的音频文件。如图下：

      上面方法描述中，实现边录制边写入的功能倒比较简单，关键难点是如何将PCM二进制数据编码成目标的m4a格式的音频数据，要实现音视频的编解码，一般都是使用第三方开源的编解码库，比较著名的有FFMpeg和Speex，这些库都提供了录制、转换以及流化音视频的完整解决方案，不过在此我的需求只是需要简单地实现编码工作，使用这些开源库体积太大，有点杀鸡用牛刀的感觉。因此，通过研究和查阅资料，我在github上找到了一个非常有用的编解码开源项目android-aac-enc(地址：https://github.com/timsu/android-aac-enc)，该开源项目能完美地实现将原始的pcm格式的二进制数据编码成m4a格式的数据文件，相比于FFmpeg库，这个库有以下几点优点：

    1. aac-enc库的体积比FFmpeg库的体积更小；

    2. 相比FFMpeg, aac-enc实现格式转换更加简单和快速；

    3. aac-enc比FFmpeg需要编译更少的底层的代码。

该开源项目使用起来也非常地简单，通过分析其示例代码我们可以通过以下四个步骤来实现音频的编码工作，代码如下：

[java]  view plain copy

1. /** 
2.      * 1.初始化编码配置 
3.      *  
4.      * 32000 : 音频的比特率 
5.      * 2 : 音频的声道 
6.      * sampleRateInHz : 音频采样率 
7.      * 16 :音频数据格式，PCM 16位每个样本 
8.      * FileUtils.getAAcFilePath(mAudioRecordFileName) : aac音频文件的存储路径 
9.      */  
10.     encoder.init(32000, 2, sampleRateInHz, 16, FileUtils.  
11.             getAAcFilePath(mAudioRecordFileName));  
12.     /** 
13.      * 2.对二进制代码进行编码 
14.      *  
15.      * b :需要编码的二进制音频流 
16.      */  
17.     encoder.encode(b);  
18.     /** 
19.      * 3. 从pcm二进制数据转aac音频文件编码完成 
20.      *  
21.      */  
22.     encoder.uninit();  
23.     /** 
24.      * 4. 将aac文件转码成m4a文件 
25.      *  
26.      * FileUtils.getAAcFilePath(mAudioRecordFileName) :需要编码的aac文件路径 
27.      * FileUtils.getM4aFilePath(mAudioRecordFileName) :编码成m4a文件的目标路径 
28.      */  
29.     new AACToM4A().convert(mContext, FileUtils.getAAcFilePath(mAudioRecordFileName),   
30.             FileUtils.getM4aFilePath(mAudioRecordFileName));  

使用起来是不是很简单方便，我们无需对音频文件格式和文件头进行判断和解析，只需要通过该开源项目封装的api方法直接调用就可以很快速的将原始的二进制PCM音频数据转换成m4a格式的音频数据文件。感兴趣的读者可以去研究一下该项目的源码，了解一下其内部的实现，这里暂且不深入探究。

      基本上明确好思路和编码的实现方法后，接下来就是具体的实现过程了，我们将依据上面的思路和方法来实现一个具有暂停功能的音频录制Demo。首先看下Demo的项目结构，如下图：

如何使用AudioRecord类来实现音频的录制，这方面的资料很多，读者可以先学习，简单地入一下门。接下来我们先运行一下Demo，来看一下效果图：

          

                  (1)初始界面                                        (2)正在录制界面                                    (2)暂停界面

   

                  (4)播放界面                                       (5)暂停播放界面

粗略看了Demo的运行效果图后，接下来我们就要来实现，这里由于要使用aac-encode项目来实现音频的编码，则需将该项目以library的形式集成到我们的Demo中，做完该项工作后，我们就可以在Demo工程中写其它相关的逻辑代码了，下面看一下实现demo的关键代码，首先是RecordAct.java文件中的代码，该类为主界面类，主要实现了界面的初始化、音频的录制和音频播放的功能，具体的代码如下：

[java]  view plain copy

1. public class RecordAct extends Activity implements OnClickListener{  
2.   
3.     /** 
4.      * Status：录音初始状态 
5.      */  
6.     private static final int STATUS_PREPARE = 0;  
7.       
8.     /** 
9.      * Status：正在录音中 
10.      */  
11.     private static final int STATUS_RECORDING = 1;  
12.       
13.     /** 
14.      * Status：暂停录音 
15.      */  
16.     private static final int STATUS_PAUSE = 2;  
17.       
18.     /** 
19.      * Status：播放初始状态 
20.      */  
21.     private static final int STATUS_PLAY_PREPARE = 3;  
22.       
23.     /** 
24.      * Status：播放中 
25.      */  
26.     private static final int STATUS_PLAY_PLAYING = 4;  
27.     /** 
28.      * Status：播放暂停 
29.      */  
30.     private static final int STATUS_PLAY_PAUSE = 5;  
31.       
32.     private int status = STATUS_PREPARE;  
33.       
34.     /** 
35.      * 录音时间 
36.      */  
37.     private TextView tvRecordTime;   
38.       
39.     /** 
40.      * 录音按钮 
41.      */  
42.     private ImageView btnRecord;// 录音按钮  
43.       
44.     private PopupWindow popAddWindow;  
45.       
46.     /** 
47.      * 试听界面 
48.      */  
49.     private LinearLayout layoutListen;  
50.       
51.     /** 
52.      * 录音长度 
53.      */  
54.     private TextView tvLength;  
55.       
56.     private TextView recordContinue;  
57.       
58.     /** 
59.      * 重置按钮 
60.      */  
61.     private View resetRecord;  
62.       
63.     /** 
64.      * 结束录音 
65.      */  
66.     private View recordOver;  
67.       
68.     private ImageView audioRecordNextImage;  
69.       
70.     private TextView audioRecordNextText;  
71.       
72.     /** 
73.      * 音频播放进度 
74.      */  
75.     private TextView tvPosition;  
76.       
77.     long startTime = 0;  
78.       
79.     /** 
80.      * 最大录音长度 
81.      */  
82.     private static final int MAX_LENGTH = 300 * 1000;  
83.       
84.     private Handler handler = new Handler();  
85.       
86.     private Runnable runnable;  
87.       
88.     /** 
89.      * 音频录音的总长度 
90.      */  
91.     private static int voiceLength;  
92.       
93.     /** 
94.      * 音频录音帮助类 
95.      */  
96.     private AudioRecordUtils mRecordUtils;  
97.       
98.     /** 
99.      * 播放进度条 
100.      */  
101.     private SeekBar seekBar;  
102.     /** 
103.      * 音频播放类 
104.      */  
105.     private Player player;  
106.     /** 
107.      * 录音文件名 
108.      */  
109.     private String audioRecordFileName;  
110.       
111.       
112.     @Override  
113.     protected void onCreate(Bundle savedInstanceState) {  
114.         // TODO Auto-generated method stub  
115.         super.onCreate(savedInstanceState);  
116.         setContentView(R.layout.pop_add_record);  
117.         initView();  
118.     }  
119.       
120.     public void initView(){  
121.         //音频录音的文件名称  
122.         audioRecordFileName = TimeUtils.getTimestamp();  
123.         //初始化音频录音对象  
124.         mRecordUtils = new AudioRecordUtils(this,audioRecordFileName);  
125.         View view = LayoutInflater.from(this).inflate(R.layout.pop_add_record, null);  
126.         tvRecordTime = (TextView)findViewById(R.id.tv_time);  
127.         btnRecord = (ImageView)findViewById(R.id.iv_btn_record);  
128.         btnRecord.setOnClickListener(this);  
129.         recordContinue = (TextView)findViewById(R.id.record_continue_txt);  
130.         resetRecord = findViewById(R.id.btn_record_reset);  
131.         recordOver = findViewById(R.id.btn_record_complete);  
132.         resetRecord.setOnClickListener(this);  
133.         recordOver.setOnClickListener(this);  
134.         audioRecordNextImage = (ImageView)findViewById(R.id.recrod_complete_img);  
135.         audioRecordNextText = (TextView)findViewById(R.id.record_complete_txt);  
136.           
137.         layoutListen = (LinearLayout)findViewById(R.id.layout_listen);  
138.         tvLength = (TextView)findViewById(R.id.tv_length);  
139.         tvPosition = (TextView)findViewById(R.id.tv_position);  
140.         seekBar = (SeekBar)findViewById(R.id.seekbar_play);  
141.         seekBar.setOnSeekBarChangeListener(new SeekBarChangeEvent());  
142.         seekBar.setEnabled(false);  
143.         player = new Player(seekBar, tvPosition);  
144.         player.setMyPlayerCallback(new MyPlayerCallback() {  
145.   
146.             @Override  
147.             public void onPrepared() {  
148.                 seekBar.setEnabled(true);  
149.             }  
150.             @Override  
151.             public void onCompletion() {  
152.                 status = STATUS_PLAY_PREPARE;  
153.                 seekBar.setEnabled(false);  
154.                 seekBar.setProgress(0);  
155.                 tvPosition.setText("00:00");  
156.                 recordContinue.setBackgroundResource(R.drawable.record_audio_play);  
157.             }  
158.         });  
159.           
160.         popAddWindow = new PopupWindow(view, LayoutParams.MATCH_PARENT,  
161.                 LayoutParams.MATCH_PARENT);  
162.         popAddWindow.setFocusable(true);  
163.         popAddWindow.setAnimationStyle(R.style.pop_anim);  
164.         popAddWindow.setBackgroundDrawable(new BitmapDrawable());  
165.     }  
166.       
167.     public void handleRecord(){  
168.         switch(status){  
169.         case STATUS_PREPARE:  
170.             mRecordUtils.startRecord();  
171.             btnRecord.setBackgroundResource(R.drawable.record_round_red_bg);  
172.             status = STATUS_RECORDING;  
173.             voiceLength = 0;  
174.             timing();  
175.             break;  
176.         case STATUS_RECORDING:  
177.             pauseAudioRecord();  
178.             resetRecord.setVisibility(View.VISIBLE);  
179.             recordOver.setVisibility(View.VISIBLE);  
180.             btnRecord.setBackgroundResource(R.drawable.record_round_blue_bg);  
181.             recordContinue.setVisibility(View.VISIBLE);  
182.             status = STATUS_PAUSE;  
183.             break;  
184.         case STATUS_PAUSE:  
185.             mRecordUtils.startRecord();  
186.             resetRecord.setVisibility(View.INVISIBLE);  
187.             recordOver.setVisibility(View.INVISIBLE);  
188.             btnRecord.setBackgroundResource(R.drawable.record_round_red_bg);  
189.             recordContinue.setVisibility(View.INVISIBLE);  
190.             status = STATUS_RECORDING;  
191.             timing();  
192.             break;  
193.         case STATUS_PLAY_PREPARE:  
194.             player.playUrl(FileUtils.getM4aFilePath(audioRecordFileName));  
195.             recordContinue.setBackgroundResource(R.drawable.record_audio_play_pause);  
196.             status = STATUS_PLAY_PLAYING;  
197.             break;  
198.         case STATUS_PLAY_PLAYING:  
199.             player.pause();  
200.             recordContinue.setBackgroundResource(R.drawable.record_audio_play);  
201.             status = STATUS_PLAY_PAUSE;  
202.             break;  
203.         case STATUS_PLAY_PAUSE:  
204.             player.play();  
205.             recordContinue.setBackgroundResource(R.drawable.record_audio_play_pause);  
206.             status = STATUS_PLAY_PLAYING;  
207.             break;  
208.         }  
209.     }  
210.     /** 
211.      * 暂停录音 
212.      */  
213.     public void pauseAudioRecord(){  
214.         mRecordUtils.pauseRecord();  
215.         if (handler != null && runnable != null) {  
216.             handler.removeCallbacks(runnable);  
217.             runnable = null;  
218.         }  
219.     }  
220.       
221.     /** 
222.      * 停止录音 
223.      */  
224.     public void stopAudioRecord(){  
225.         pauseAudioRecord();  
226.         mRecordUtils.stopRecord();  
227.         status = STATUS_PLAY_PREPARE;  
228.         showListen();  
229.     }  
230.       
231.     /** 
232.      * 重新录音参数初始化 
233.      */  
234.     @SuppressLint("NewApi")  
235.     public void resetAudioRecord(){  
236.         //停止播放音频  
237.         player.stop();  
238.         pauseAudioRecord();  
239.         mRecordUtils.reRecord();  
240.         status = STATUS_PREPARE;  
241.         voiceLength = 0;  
242.         tvRecordTime.setTextColor(Color.WHITE);  
243.         tvRecordTime.setText(TimeUtils.convertMilliSecondToMinute2(voiceLength));  
244.         recordContinue.setText(R.string.record_continue);  
245.         recordContinue.setBackground(null);  
246.         recordContinue.setVisibility(View.GONE);  
247.         layoutListen.setVisibility(View.GONE);  
248.         tvRecordTime.setVisibility(View.VISIBLE);  
249.         audioRecordNextImage.setImageResource(R.drawable.btn_record_icon_complete);  
250.         audioRecordNextText.setText(R.string.record_over);  
251.         btnRecord.setBackgroundResource(R.drawable.record_round_blue_bg);  
252.         resetRecord.setVisibility(View.INVISIBLE);  
253.         recordOver.setVisibility(View.INVISIBLE);  
254.     }  
255.       
256.     /** 
257.      * 计时功能 
258.      */  
259.     private void timing() {  
260.         runnable = new Runnable() {  
261.             @Override  
262.             public void run() {  
263.                 voiceLength += 100;  
264.                 if (voiceLength >= (MAX_LENGTH - 10 * 1000)) {  
265.                     tvRecordTime.setTextColor(getResources().getColor(  
266.                             R.color.red_n));  
267.                 } else {  
268.                     tvRecordTime.setTextColor(Color.WHITE);  
269.                 }  
270.                 if (voiceLength > MAX_LENGTH) {  
271.                     stopAudioRecord();  
272.                       
273.                 } else {  
274.                     tvRecordTime.setText(TimeUtils.convertMilliSecondToMinute2(voiceLength));  
275.                     handler.postDelayed(this, 100);  
276.                 }  
277.             }  
278.         };  
279.         handler.postDelayed(runnable, 100);  
280.     }  
281.       
282.     @Override  
283.     public void onClick(View v) {  
284.         // TODO Auto-generated method stub  
285.         switch (v.getId()) {  
286.         case R.id.iv_btn_record:  
287.             handleRecord();  
288.             break;  
289.         case R.id.btn_record_reset:  
290.             resetAudioRecord();  
291.             break;  
292.         case R.id.btn_record_complete:  
293.             stopAudioRecord();  
294.             break;  
295.         default:  
296.             break;  
297.         }  
298.     }  
299.       
300.     /** 
301.      * 显示播放界面 
302.      */  
303.     private void showListen() {  
304.         layoutListen.setVisibility(View.VISIBLE);  
305.         tvLength.setText(TimeUtils.convertMilliSecondToMinute2(voiceLength));  
306.         tvRecordTime.setVisibility(View.GONE);  
307.         resetRecord.setVisibility(View.VISIBLE);  
308.         recordOver.setVisibility(View.INVISIBLE);  
309.         recordContinue.setVisibility(View.VISIBLE);  
310.         seekBar.setProgress(0);  
311.         tvPosition.setText("00:00");  
312.         btnRecord.setBackgroundResource(R.drawable.record_round_blue_bg);  
313.         recordContinue.setText(null);  
314.         recordContinue.setBackgroundResource(R.drawable.record_audio_play);  
315.           
316.     }  
317.       
318.     /** 
319.      *  
320.      * SeekBar进度条改变事件监听类 
321.      */  
322.     class SeekBarChangeEvent implements SeekBar.OnSeekBarChangeListener {  
323.         int progress;  
324.   
325.         @Override  
326.         public void onProgressChanged(SeekBar seekBar, int progress,  
327.                 boolean fromUser) {  
328.             if (null != player && player.mediaPlayer != null) {  
329.                 this.progress = progress * player.mediaPlayer.getDuration()  
330.                         / seekBar.getMax();  
331.                 tvPosition.setText(TimeUtils  
332.                         .convertMilliSecondToMinute2(player.currentPosition));  
333.             }  
334.         }  
335.   
336.         @Override  
337.         public void onStartTrackingTouch(SeekBar seekBar) {  
338.   
339.         }  
340.   
341.         @Override  
342.         public void onStopTrackingTouch(SeekBar seekBar) {  
343.             if (player.mediaPlayer != null) {  
344.                 player.mediaPlayer.seekTo(progress);  
345.             }  
346.         }  
347.     }  
348.       
349.     @Override  
350.     protected void onDestroy() {  
351.         // TODO Auto-generated method stub  
352.         super.onDestroy();  
353.         player.stop();  
354.     }  
355.       
356. }  

上面代码注释比较清楚，且好理解，因此不多分析，读者自行学习。下面再来看一下AudioRecordUtils类的代码，该类是音频录制功能的主要实现代码，里面简单地封装了开始录音、暂停录音、停止录音和重新录音几个方法，在开发中只要调用就行，来看看具体的实现代码，如下：

[java]  view plain copy

1. public class AudioRecordUtils {  
2.   
3.     private final int audioSource = MediaRecorder.AudioSource.MIC;  
4.     // 设置音频采样率，44100是目前的标准，但是某些设备仍然支持22050,16000,11025  
5.     private final int sampleRateInHz = 16000;  
6.     // 设置音频的录制的声道CHANNEL_IN_STEREO为双声道，CHANNEL_CONFIGURATION_MONO为单声道  
7.     private final int channelConfig = AudioFormat.CHANNEL_IN_STEREO;  
8.     // 音频数据格式:PCM 16位每个样本。保证设备支持。PCM 8位每个样本。不一定能得到设备支持。  
9.     private final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;  
10.       
11.     private int inBufSize = 0;  
12.       
13.     private AudioRecord audioRecord;  
14.       
15.     private AACEncoder encoder = null;  
16.       
17.     private ProgressDialog mProgressDialog = null;  
18.       
19.     private boolean isRecord = false;  
20.       
21.     private Context mContext;  
22.     /** 
23.      * 录制的音频文件名称 
24.      */  
25.     private String mAudioRecordFileName;  
26.       
27.     private static final int RECORDED_INIT_DELETE = 0;  
28.       
29.     private static final int RECORDED_COMPLETED_DELETE = 1;  
30.       
31.       
32.     public AudioRecordUtils(Context context,String audioRecordFileName){  
33.         mContext = context;  
34.         mAudioRecordFileName = audioRecordFileName;  
35.         initAudioRecord();  
36.     }  
37.       
38.     /** 
39.      * 初始化对象 
40.      */  
41.     private void initAudioRecord(){  
42.           
43.         inBufSize = AudioRecord.getMinBufferSize(  
44.                 sampleRateInHz,   
45.                 channelConfig,   
46.                 audioFormat);  
47.           
48.         audioRecord  = new AudioRecord(  
49.                 audioSource,   
50.                 sampleRateInHz,   
51.                 channelConfig,   
52.                 audioFormat,   
53.                 inBufSize);  
54.           
55.         encoder = new AACEncoder();  
56.         deleteAllFiles(RECORDED_INIT_DELETE);  
57.           
58.         mProgressDialog = new ProgressDialog(mContext);  
59.         mProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);  
60.         mProgressDialog.setCanceledOnTouchOutside(false);  
61.         mProgressDialog.setCancelable(false);  
62.         mProgressDialog.setTitle("提示");  
63.         mProgressDialog.setMessage("正在保存录音，请耐心等候......");  
64.           
65.     }  
66.       
67.     /** 
68.      * 开始录音 
69.      */  
70.     public void startRecord(){  
71.         new AudioRecordTask().execute();  
72.     }  
73.       
74.     /** 
75.      * 暂停录音 
76.      */  
77.     public void pauseRecord(){  
78.         isRecord = false;  
79.     }  
80.       
81.     /** 
82.      * 停止录音 
83.      */  
84.     public void stopRecord(){  
85.         new AudioEncoderTask().execute();  
86.     }  
87.       
88.     /** 
89.      * 重新录制 
90.      */  
91.     public void reRecord(){  
92.         //重新录制时，删除录音文件夹中的全部文件  
93.         deleteAllFiles(RECORDED_INIT_DELETE);  
94.     }   
95.       
96.     private void encodeAudio(){  
97.         try {  
98.             //读取录制的pcm音频文件  
99.             DataInputStream mDataInputStream = new DataInputStream(new FileInputStream(  
100.                     FileUtils.getPcmFilePath(mAudioRecordFileName)));  
101.                 byte[] b = new byte[(int) new File(FileUtils.  
102.                         getPcmFilePath(mAudioRecordFileName)).length()];  
103.                 mDataInputStream.read(b);  
104.                 //初始化编码配置  
105.                 encoder.init(32000, 2, sampleRateInHz, 16, FileUtils.  
106.                         getAAcFilePath(mAudioRecordFileName));  
107.                 //对二进制代码进行编码  
108.                 encoder.encode(b);  
109.                 //编码完成  
110.                 encoder.uninit();  
111.                 //关闭流  
112.                 mDataInputStream.close();  
113.                 try {  
114.                     //将aac文件转码成m4a文件  
115.                     new AACToM4A().convert(mContext, FileUtils.getAAcFilePath(mAudioRecordFileName),   
116.                             FileUtils.getM4aFilePath(mAudioRecordFileName));  
117.                 } catch (IOException e) {  
118.                     Log.e("ERROR", "error converting", e);  
119.                 }  
120.                 deleteAllFiles(RECORDED_COMPLETED_DELETE);  
121.             } catch (FileNotFoundException e) {  
122.                 // TODO Auto-generated catch block  
123.                 e.printStackTrace();  
124.             } catch (IOException e1) {  
125.                 // TODO Auto-generated catch block  
126.                 e1.printStackTrace();  
127.             }  
128.     }  
129.       
130.     class AudioRecordTask extends AsyncTask<Void, Void, Void>{  
131.   
132.         @Override  
133.         protected Void doInBackground(Void... params) {  
134.             // TODO Auto-generated method stub  
135.             if(audioRecord == null){  
136.                 initAudioRecord();  
137.             }  
138.             RandomAccessFile mRandomAccessFile = null;  
139.             try {  
140.                 mRandomAccessFile = new RandomAccessFile(new File(  
141.                         FileUtils.getPcmFilePath(mAudioRecordFileName)), "rw");  
142.                 byte[] b = new byte[inBufSize/4];  
143.                 //开始录制音频  
144.                 audioRecord.startRecording();  
145.                 //判断是否正在录制  
146.                 isRecord = true;  
147.                 while(isRecord){  
148.                     audioRecord.read(b, 0, b.length);  
149.                     //向文件中追加内容  
150.                     mRandomAccessFile.seek(mRandomAccessFile.length());  
151.                     mRandomAccessFile.write(b, 0, b.length);  
152.                 }  
153.                 //停止录制  
154.                 audioRecord.stop();  
155.                 mRandomAccessFile.close();  
156.             } catch (FileNotFoundException e) {  
157.                 // TODO Auto-generated catch block  
158.                 e.printStackTrace();  
159.             } catch (IOException e) {  
160.                 // TODO Auto-generated catch block  
161.                 e.printStackTrace();  
162.             }  
163.             return null;  
164.         }  
165.     }  
166.       
167.     class AudioEncoderTask extends AsyncTask<Void, Void, Long>{  
168.   
169.         @Override  
170.         protected void onPreExecute() {  
171.             // TODO Auto-generated method stub  
172.             super.onPreExecute();  
173.             if(mProgressDialog != null && !mProgressDialog.isShowing()){  
174.                 mProgressDialog.show();  
175.             }  
176.         }  
177.   
178.         @Override  
179.         protected Long doInBackground(Void... params) {  
180.             // TODO Auto-generated method stub  
181.             encodeAudio();  
182.             return null;  
183.         }  
184.   
185.         @Override  
186.         protected void onPostExecute(Long result) {  
187.             // TODO Auto-generated method stub  
188.             super.onPostExecute(result);  
189.             if(mProgressDialog.isShowing()){  
190.                 mProgressDialog.cancel();  
191.                 mProgressDialog.dismiss();  
192.             }  
193.         }  
194.     }  
195.       
196.     /** 
197.      * 清空音频录制文件夹中的所有文件 
198.      * @param isRecorded 
199.      */  
200.     public void deleteAllFiles(int isRecorded){  
201.          File[] files = new File(FileUtils.getAudioRecordFilePath()).listFiles();  
202.         switch (isRecorded) {  
203.         case RECORDED_INIT_DELETE:  
204.             for(File file: files){  
205.                 file.delete();  
206.             }  
207.             break;  
208.         case RECORDED_COMPLETED_DELETE:  
209.             for(File file: files){  
210.                 if(!file.getName().equals(mAudioRecordFileName + Constants.M4A_SUFFIX)){  
211.                     file.delete();  
212.                 }  
213.             }  
214.             break;  
215.         default:  
216.             break;  
217.         }  
218.     }  
219. }  

      上面代码关键处都有注释，读者可自行学习。自此，我们基本熟悉了实现能够暂停录音功能的关键代码，代码没有全部贴出，想要完整的Demo可在文章末尾下载来仔细研究。最后我再补充一点，就是若读者对录制的音频格式没有严格的要求话，如录制的音频格式是arm格式，则没有必要考虑到音频的编解码问题，因为arm格式的音频文件的文件头信息固定是6个字节的大小，那这种情况读者可以采用文章开头所说的第一种方法，就是每次点击暂停事件都录制成一个arm文件，在最后合并的时候，只需要去掉第2至n个文件的前6个字节，然后进行文件的拷贝合并就行，这里有一篇采用该方法的的文章(地址：http://blog.csdn.net/wanli_smile/article/details/7715030)，有需求的读者应该会有所收获。

源代码下载，请戳下面：

• GITHUB下载
• CSDN下载