如何在不同Android设备中得到有效的AudioRecord实例

import java.nio.ByteBuffer; 
 
import android.media.AudioFormat; 
import android.media.AudioRecord; 
import android.media.MediaRecorder.AudioSource; 
import android.os.Process; 
 
/** 
 * Basically what this class does is construct a valid AudioRecord Object, wrap AudioRecord methods, and provide 
 * conversion to decibels. It also caches the AudioRecord configuration and prevents multiple instances of the recorder. 
 *  
 * @author Michael-Pardo/billhoo 
 * @version 0.1 2013-2-18 
 */ 
// TODO(billhoo) the AudioMeter.createAudioRecord() method always returned the first matched configuration currently, 
// if the first combination [8000Hz + PCM16 + IN_MONO] is valid, method returns, but there is no way if I wanna use 
// 16000Hz instead, so this method should be changed to a clever one in the future. 
public class AudioMeter extends Thread { 
 
    // /////////////////////////////////////////////////////////////// 
    // PRIVATE CONSTANTS 
 
    private static final float MAX_REPORTABLE_AMP = 32767f; 
    private static final float MAX_REPORTABLE_DB  = 90.3087f; 
 
    // /////////////////////////////////////////////////////////////// 
    // PRIVATE MEMBERS 
 
    private AudioRecord        mAudioRecord; 
    private int                mSampleRate; 
    private short              mAudioFormat; 
    private short              mChannelConfig; 
 
    private short[]            mBuffer; 
    private int                mBufferSize        = AudioRecord.ERROR_BAD_VALUE; 
 
    private int                mLocks             = 0; 
 
    // /////////////////////////////////////////////////////////////// 
    // CONSTRUCTOR 
 
    private AudioMeter() { 
        Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO); // set the AudioMeter thread in URGENT_AUDIO 
                                                                         // priority. 
        createAudioRecord(); 
    } 
 
    // /////////////////////////////////////////////////////////////// 
    // PUBLIC METHODS 
 
    public static AudioMeter getInstance() { 
        return InstanceHolder.INSTANCE; 
    } 
 
    public float getAmplitude() { 
        return (float) (MAX_REPORTABLE_DB + (20 * Math.log10(getRawAmplitude() 
                / MAX_REPORTABLE_AMP))); 
    } 
 
    public synchronized void startRecording() { 
        if (mAudioRecord == null 
                || mAudioRecord.getState() != AudioRecord.STATE_INITIALIZED) { 
            throw new IllegalStateException( 
                    "startRecording() called on an uninitialized AudioRecord."); 
        } 
 
        if (mLocks == 0) { 
            mAudioRecord.startRecording(); 
        } 
 
        mLocks++; 
    } 
 
    public synchronized void stopRecording() { 
        mLocks--; 
 
        if (mLocks == 0) { 
            if (mAudioRecord != null) { 
                mAudioRecord.stop(); 
                mAudioRecord.release(); 
                mAudioRecord = null; 
            } 
        } 
    } 
 
    /** 
     * Reads audio data from the audio hardware for recording into a direct buffer. If this buffer is not a direct 
     * buffer, this method will always return 0. 
     *  
     * @param audioBuffer 
     *            the direct buffer to which the recorded audio data is written. 
     * @param sizeInBytes 
     *            the number of requested bytes. 
     * @return the number of bytes that were read or or {@link #ERROR_INVALID_OPERATION} if the object wasn't properly 
     *         initialized, or {@link #ERROR_BAD_VALUE} if the parameters don't resolve to valid data and indexes. The 
     *         number of bytes will not exceed sizeInBytes. 
     */ 
    public int read(ByteBuffer audioBuffer, int sizeInBytes) { 
        return mAudioRecord.read(audioBuffer, sizeInBytes); 
    } 

    public int read(short[] audioData, int offsetInShorts, int sizeInShorts) { 
        return mAudioRecord.read(audioData, offsetInShorts, sizeInShorts); 
    } 
 

    public int read(byte[] audioData, int offsetInBytes, int sizeInBytes) { 
        return mAudioRecord.read(audioData, offsetInBytes, sizeInBytes); 
    } 
 
 
    public int getSampleRate() { 
        return mSampleRate; 
    } 
 
   
    public int getAudioFormat() { 
        return mAudioFormat; 
    } 
 

    public int getChannelConfiguration() { 
        return mChannelConfig; 
    } 
 

    public int getAudioRecordState() { 
        return mAudioRecord.getState(); 
    } 
 

 
    private void createAudioRecord() { 
        if (mSampleRate > 0 && mAudioFormat > 0 && mChannelConfig > 0) { 
            mAudioRecord = new AudioRecord(AudioSource.MIC, mSampleRate, 
                    mChannelConfig, mAudioFormat, mBufferSize); 
            return; 
        } 
 

        for (int sampleRate : new int[] { 8000, 11025, 16000, 22050, 32000, 
                44100, 47250, 48000 }) { 
            for (short audioFormat : new short[] { 
                    AudioFormat.ENCODING_PCM_16BIT, 
                    AudioFormat.ENCODING_PCM_8BIT }) { 
                for (short channelConfig : new short[] { 
                        AudioFormat.CHANNEL_IN_MONO, 
                        AudioFormat.CHANNEL_IN_STEREO, 
                        AudioFormat.CHANNEL_CONFIGURATION_MONO, 
                        AudioFormat.CHANNEL_CONFIGURATION_STEREO }) { 
 
                    // Try to initialize 
                    try { 
                        mBufferSize = AudioRecord.getMinBufferSize(sampleRate, 
                                channelConfig, audioFormat); 
 
                        if (mBufferSize < 0) { 
                            continue; 
                        } 
 
                        mBuffer = new short[mBufferSize]; 
                        mAudioRecord = new AudioRecord(AudioSource.MIC, 
                                sampleRate, channelConfig, audioFormat, 
                                mBufferSize); 
 
                        if (mAudioRecord.getState() == AudioRecord.STATE_INITIALIZED) { 
                            mSampleRate = sampleRate; 
                            mAudioFormat = audioFormat; 
                            mChannelConfig = channelConfig; 
                            return; 
                        } 
 
                        mAudioRecord.release(); 
                        mAudioRecord = null; 
                    } catch (Exception e) { 
                        // Do nothing 
                    } 
                } 
            } 
        } 
 
               throw new IllegalStateException( 
                "getInstance() failed : no suitable audio configurations on this device."); 
    } 
 
    private int getRawAmplitude() { 
        if (mAudioRecord == null) { 
            createAudioRecord(); 
        } 
 
        final int bufferReadSize = mAudioRecord.read(mBuffer, 0, mBufferSize); 
 
        if (bufferReadSize < 0) { 
            return 0; 
        } 
 
        int sum = 0; 
        for (int i = 0; i < bufferReadSize; i++) { 
            sum += Math.abs(mBuffer[i]); 
        } 
 
        if (bufferReadSize > 0) { 
            return sum / bufferReadSize; 
        } 
 
        return 0; 
    } 
 

    private static class InstanceHolder { 
        private static final AudioMeter INSTANCE = new AudioMeter(); 
    } 
}