android判断是否禁用了录音权限

最新推荐文章于 2024-07-11 14:35:47 发布

插上翅膀的老虎

最新推荐文章于 2024-07-11 14:35:47 发布

阅读量9.8k

点赞数 1

分类专栏： android

本文链接：https://blog.csdn.net/xiangyihu/article/details/50951284

版权

android 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

问题：

1、android判断是否禁用了录音权限

通过判断分贝值是否大于0，在代码中搜索 volume > 0

2、部分手机在调用 audioRecord.startRecording(); 和audioRecord.stop();方法时会抛出异常，例如联想手机

3、部分手机（例如联想）会抛出java.lang.IllegalStateException: startRecording() called on an uninitialized AudioRecord.

解决方法来源于：http://www.cnblogs.com/mythou/p/3241925.html

原因：

出现上面问题的原因是录音的硬件资源被申请了，但是没有释放，然后你再次申请资源，导致初始化失败。这里需要注意的是不仅仅需要调用Release()方法。还需要把AudioRecord对象置为null，否则还是释放失败。下面是Android 开发网上面的一个对于AudioRecord的释放说明。

Releases the native AudioRecord resources. The object can no longer be used and the reference should be set to null after a call to release()。

解决方法在代码中：

 
   [java]  
   view plain 
  
 package com.androidleaf.audiorecord;  
   
 import android.app.ProgressDialog;  
 import android.content.Context;  
 import android.media.AudioFormat;  
 import android.media.AudioRecord;  
 import android.media.MediaRecorder;  
 import android.os.AsyncTask;  
 import android.os.Bundle;  
 import android.os.Handler;  
 import android.os.Message;  
 import android.util.Log;  
   
 import com.hisun.phone.core.voice.Device;  
 import com.todoroo.aacenc.AACEncoder;  
 import com.todoroo.aacenc.AACToM4A;  
   
 import java.io.DataInputStream;  
 import java.io.File;  
 import java.io.FileInputStream;  
 import java.io.FileNotFoundException;  
 import java.io.IOException;  
 import java.io.RandomAccessFile;  
   
 import app.jimu.zhiyu.activity.question.AnswerActivity;  
   
 public class AudioRecordUtils {  
   
     private final int audioSource = MediaRecorder.AudioSource.MIC;  
     // 设置音频采样率，44100是目前的标准，但是某些设备仍然支持22050,16000,11025  
     private final int sampleRateInHz = 16000;  
     // 设置音频的录制的声道CHANNEL_IN_STEREO为双声道，CHANNEL_CONFIGURATION_MONO为单声道  
     private final int channelConfig = AudioFormat.CHANNEL_IN_STEREO;  
     // 音频数据格式:PCM 16位每个样本。保证设备支持。PCM 8位每个样本。不一定能得到设备支持。  
     private final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;  
       
     private int inBufSize = 0;  
       
     private AudioRecord audioRecord;  
       
     private AACEncoder encoder = null;  
       
     private ProgressDialog mProgressDialog = null;  
       
     private boolean isRecord = false;  
       
     private Context mContext;  
     /** 
      * 录制的音频文件名称 
      */  
     private String mAudioRecordFileName;  
       
     private static final int RECORDED_INIT_DELETE = 0;  
       
     private static final int RECORDED_COMPLETED_DELETE = 1;  
   
     private Handler mHandler;  
   
     /** 
      * 是否可以录音 true 可以录音 
      */  
     private boolean recordEnable = false;  
       
     public AudioRecordUtils(Context context,String audioRecordFileName, Handler handler){  
         mContext = context;  
         mAudioRecordFileName = audioRecordFileName;  
         mHandler = handler;  
         initAudioRecord();  
     }  
       
     /** 
      * 初始化对象 
      */  
     private void initAudioRecord(){  
           
         inBufSize = AudioRecord.getMinBufferSize(  
                 sampleRateInHz,   
                 channelConfig,   
                 audioFormat);  
           
         audioRecord  = new AudioRecord(  
                 audioSource,   
                 sampleRateInHz,   
                 channelConfig,   
                 audioFormat,   
                 inBufSize);  
           
         encoder = new AACEncoder();  
         deleteAllFiles(RECORDED_INIT_DELETE);  
           
         mProgressDialog = new ProgressDialog(mContext);  
         mProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);  
         mProgressDialog.setCanceledOnTouchOutside(false);  
         mProgressDialog.setCancelable(false);  
         mProgressDialog.setTitle("提示");  
         mProgressDialog.setMessage("正在保存录音，请耐心等候......");  
           
     }  
       
     /** 
      * 开始录音 
      */  
     public void startRecord(){  
         new AudioRecordTask().execute();  
     }  
       
     /** 
      * 暂停录音 
      */  
     public void pauseRecord(){  
         isRecord = false;  
     }  
       
     /** 
      * 停止录音 
      */  
     public void stopRecord(){  
         new AudioEncoderTask().execute();  
     }  
       
     /** 
      * 重新录制 
      */  
     public void reRecord(){  
         //重新录制时，删除录音文件夹中的全部文件  
         deleteAllFiles(RECORDED_INIT_DELETE);  
     }   
       
     private void encodeAudio(){  
         try {  
             //读取录制的pcm音频文件  
             DataInputStream mDataInputStream = new DataInputStream(new FileInputStream(  
                     FileUtils.getPcmFilePath(mAudioRecordFileName)));  
                 byte[] b = new byte[(int) new File(FileUtils.  
                         getPcmFilePath(mAudioRecordFileName)).length()];  
                 mDataInputStream.read(b);  
                 //初始化编码配置  
                 encoder.init(32000, 2, sampleRateInHz, 16, FileUtils.  
                         getAAcFilePath(mAudioRecordFileName));  
                 //对二进制代码进行编码  
                 encoder.encode(b);  
                 //编码完成  
                 encoder.uninit();  
                 //关闭流  
                 mDataInputStream.close();  
                 try {  
                     //将aac文件转码成m4a文件  
                     new AACToM4A().convert(mContext, FileUtils.getAAcFilePath(mAudioRecordFileName),   
                             FileUtils.getM4aFilePath(mAudioRecordFileName));  
                 } catch (IOException e) {  
                     Log.e("ERROR", "error converting", e);  
                 }  
                 deleteAllFiles(RECORDED_COMPLETED_DELETE);  
             } catch (FileNotFoundException e) {  
                 // TODO Auto-generated catch block  
                 e.printStackTrace();  
             } catch (IOException e1) {  
                 // TODO Auto-generated catch block  
                 e1.printStackTrace();  
             }  
     }  
       
     class AudioRecordTask extends AsyncTask<Void, Void, Void>{  
   
         @Override  
         protected Void doInBackground(Void... params) {  
             // TODO Auto-generated method stub  
             if(audioRecord == null){  
                 initAudioRecord();  
             }  
             RandomAccessFile mRandomAccessFile = null;  
             try {  
                 mRandomAccessFile = new RandomAccessFile(new File(  
                         FileUtils.getPcmFilePath(mAudioRecordFileName)), "rw");  
                 byte[] b = new byte[inBufSize/4];  
                 //开始录制音频  
                 try{  
                     // 防止某些手机崩溃，例如联想  
                     audioRecord.startRecording();  
                 }catch (IllegalStateException e){  
                     e.printStackTrace();  
                 }  
   
                 //判断是否正在录制  
                 isRecord = true;  
                 long wait = 0;  
                 long maxWait = 10;  
                 while(isRecord){  
                     //r是实际读取的数据长度，一般而言r会小于buffersize  
                     int r = audioRecord.read(b, 0, b.length);  
                     long v = 0;  
                     // 将 buffer 内容取出，进行平方和运算  
                     for (int i = 0; i < b.length; i++) {  
                          v += b[i] * b[i];  
                     }  
                     // 平方和除以数据总长度，得到音量大小。  
                     double mean = v / (double) r;  
                     double volume = 10 * Math.log10(mean);  
   
                     wait++;  
                     if(wait > maxWait){  
                         wait = 0;  
                         Log.d(this.getClass().getName(), "分贝值:" + volume + " " + (volume > 0));  
                         if(volume > 0){  
                             recordEnable = true;  
                         }  
                         Message msg = new Message();  
                         msg.what = AnswerActivity.STATUS_PREPARE;  
                         Bundle bundle = new Bundle();  
                         bundle.putDouble(Device.VOICE_AMPLITUDE, volume);  
                         msg.obj = bundle;  
                         mHandler.sendMessage(msg);  
                     }  
   
                     //向文件中追加内容  
                     mRandomAccessFile.seek(mRandomAccessFile.length());  
                     mRandomAccessFile.write(b, 0, b.length);  
                 }  
                 //停止录制  
                 try {  
                     // 防止某些手机崩溃，例如联想  
                     audioRecord.stop();  
                     // 彻底释放资源  
                     audioRecord.release();  
                     audioRecord = null;  
                 }catch (IllegalStateException e){  
                     e.printStackTrace();  
                 }  
                 mRandomAccessFile.close();  
             } catch (FileNotFoundException e) {  
                 // TODO Auto-generated catch block  
                 e.printStackTrace();  
             } catch (IOException e) {  
                 // TODO Auto-generated catch block  
                 e.printStackTrace();  
             }  
             return null;  
         }  
     }  
       
     class AudioEncoderTask extends AsyncTask<Void, Void, Long>{  
   
         @Override  
         protected void onPreExecute() {  
             // TODO Auto-generated method stub  
             super.onPreExecute();  
             if(mProgressDialog != null && !mProgressDialog.isShowing()){  
 //              mProgressDialog.show();  
                 Message msg = new Message();  
                 msg.what = 2;  
                 mHandler.sendMessage(msg);  
             }  
         }  
   
         @Override  
         protected Long doInBackground(Void... params) {  
             // TODO Auto-generated method stub  
             encodeAudio();  
             return null;  
         }  
   
         @Override  
         protected void onPostExecute(Long result) {  
             // TODO Auto-generated method stub  
             super.onPostExecute(result);  
             if(mProgressDialog.isShowing()){  
                 mProgressDialog.cancel();  
                 mProgressDialog.dismiss();  
             }  
         }  
     }  
       
     /** 
      * 清空音频录制文件夹中的所有文件 
      * @param isRecorded 
      */  
     public void deleteAllFiles(int isRecorded){  
          File[] files = new File(FileUtils.getAudioRecordFilePath()).listFiles();  
         switch (isRecorded) {  
         case RECORDED_INIT_DELETE:  
             for(File file: files){  
                 file.delete();  
             }  
             break;  
         case RECORDED_COMPLETED_DELETE:  
             for(File file: files){  
                 if(!file.getName().equals(mAudioRecordFileName + Constants.M4A_SUFFIX)){  
                     file.delete();  
                 }  
             }  
             break;  
         default:  
             break;  
         }  
     }  
   
     public boolean isRecordEnable() {  
         return recordEnable;  
     }  
 }  