Android: AEC:AcousticEchoCanceler回声消除

参考资料
AndroidRecord —Developers
AndroidEffect ----Developers

备注：由于权限判断逻辑有bug的原因，第一次进入获取权限后，需要重启应用

MainActicity.java

package com.example.aectest;

import android.Manifest;
import android.content.pm.PackageManager;
import android.media.AudioFormat;
import android.media.MediaRecorder;
import android.media.audiofx.AcousticEchoCanceler;
import android.media.audiofx.AudioEffect;
import android.media.audiofx.NoiseSuppressor;
import android.os.Environment;
import android.os.Process;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import android.annotation.SuppressLint;
import android.content.Context;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Log: <MainActivity> ";
    //private static final String TAG = "TAG";
    private short[] mAudioRecordData;
    private short[] mAudioTrackData;
    private static final int REQUEST_AUDIO_CONTACTS = 0;
    private static final int REQUEST_READ_CONTACTS = 0;

    private int process_sum = 0;
    private Button mStart;
    private Button mStop;
    private Button mPlay;

    private File mAudioFile;
    private AudioRecord mAudioRecord;
    private AudioTrack mAudioTrack;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getProcess(); // 获取权限
        if(checkProcess()) {
            init();
            registerListener();
        }else{
            Toast.makeText(this, "权限不足", Toast.LENGTH_SHORT).show();
        }
    }


    public boolean checkProcess(){
        if(ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.RECORD_AUDIO)== PackageManager.PERMISSION_GRANTED &&
        ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.READ_EXTERNAL_STORAGE)== PackageManager.PERMISSION_GRANTED) {
            return true;
        }else{
            return false;
        }
    }
    public void getProcess(){
        if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.RECORD_AUDIO)!= PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(
                    MainActivity.this,
                    new String[]{Manifest.permission.RECORD_AUDIO,
                            Manifest.permission.READ_EXTERNAL_STORAGE,
                            Manifest.permission.WRITE_EXTERNAL_STORAGE},
                    REQUEST_AUDIO_CONTACTS);
        }
    }
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
          if(requestCode == REQUEST_AUDIO_CONTACTS){
                // If request is cancelled, the result arrays are empty.
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    process_sum++;
                } else {
                    Toast.makeText(this, "无录音权限", Toast.LENGTH_SHORT).show();
                }

            }
          if(requestCode == REQUEST_READ_CONTACTS)  {
                // If request is cancelled, the result arrays are empty.
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    process_sum++;
                } else {
                    Toast.makeText(this, "无读取权限", Toast.LENGTH_SHORT).show();
                }
            }
        }

    private void registerListener() {

        mStart.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                Toast.makeText(MainActivity.this, "开始录音", Toast.LENGTH_SHORT).show();
                new Thread(new Runnable() {
                    public void run() {
                        Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO);
                        try {
                            mAudioRecord.startRecording();
                            Log.d(TAG, "run: start record");
                            DataOutputStream dos = new DataOutputStream(
                                    new BufferedOutputStream(
                                            new FileOutputStream(mAudioFile)));
                            while (mAudioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) {
                                int number = mAudioRecord.read(
                                        mAudioRecordData, 0,
                                        mAudioRecordData.length);
                                for (int i = 0; i < number; i++) {
                                    dos.writeShort(mAudioRecordData[i]);
                                }
                                if (AudioRecord.ERROR_BAD_VALUE == number
                                        || AudioRecord.ERROR == number) {
                                    Log.d(TAG,
                                            "Error:" + String.valueOf(number));
                                    break;
                                }
                            }
                            dos.flush();
                            dos.close();
                            Log.d(TAG, "dos.close()");
                        } catch (FileNotFoundException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        });

        mStop.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {

                if (mAudioRecord != null
                        && mAudioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) {
                    mAudioRecord.stop();
                    Toast.makeText(MainActivity.this, "终止录音", Toast.LENGTH_SHORT).show();
                }
            }
        });

        mPlay.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                Toast.makeText(MainActivity.this, "播放录音中", Toast.LENGTH_SHORT).show();
                new Thread(new Runnable() {
                    public void run() {
                        Process
                                .setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO);
                        try {
                            mAudioTrack.play();
                            Log.d(TAG, "run: AudioTrack playing~");
                            DataInputStream dis = new DataInputStream(
                                    new BufferedInputStream(
                                            new FileInputStream(mAudioFile)));
                            Log.d(TAG, "dis.available=" + dis.available());
                            int i = 0;
                            while (mAudioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING
                                    && dis.available() > 0) {
                                while (dis.available() > 0
                                        && i < mAudioTrackData.length) {
                                    mAudioTrackData[i] = dis.readShort();
                                    i++;
                                }
                                mAudioTrack.write(mAudioTrackData, 0,
                                        mAudioTrackData.length);
                                i = 0;
                            }
                            mAudioTrack.stop();
                            dis.close();
                            Log.d(TAG, "dis.close()");
                        } catch (FileNotFoundException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
                Toast.makeText(MainActivity.this, "播放结束", Toast.LENGTH_SHORT).show();
            }
        });
    }
    @SuppressLint("NewApi")
    private void init() {
        AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
        am.setMode(AudioManager.MODE_IN_COMMUNICATION); // 听筒播放录音

        mStart = (Button) findViewById(R.id.start);
        mStop = (Button) findViewById(R.id.stop);
        mPlay = (Button) findViewById(R.id.play);
        if (Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED)) {
            File file = new File(Environment.getExternalStorageDirectory()
                    .getAbsolutePath() + "/audio/");
            if (!file.exists()) {
                file.mkdirs();
            }
            mAudioFile = new File(file, System.currentTimeMillis() + ".pcm");
        } else {
            Toast.makeText(this, "The SDCard doesn't exist!", Toast.LENGTH_LONG)
                    .show();
        }

        try {
            int sampleRateInHz = 8000;// 22050, 16000, 11025,44100
            int recordBufferSizeInBytes = AudioRecord.getMinBufferSize(
                    sampleRateInHz, AudioFormat.CHANNEL_IN_MONO,
                    AudioFormat.ENCODING_PCM_16BIT);
            Log.d(TAG, "recordBufferSizeInBytes=" + recordBufferSizeInBytes);
            mAudioRecordData = new short[recordBufferSizeInBytes];
            mAudioRecord = new AudioRecord(
                    MediaRecorder.AudioSource.VOICE_COMMUNICATION,
                    sampleRateInHz, AudioFormat.CHANNEL_IN_MONO,
                    AudioFormat.ENCODING_PCM_16BIT, recordBufferSizeInBytes*2);

            if (isAECAailable()) {
                AcousticEchoCanceler acousticEchoCanceler = AcousticEchoCanceler
                        .create(mAudioRecord.getAudioSessionId());
                int resultCode = acousticEchoCanceler.setEnabled(true);
                if (AudioEffect.SUCCESS == resultCode) {
                    Toast.makeText(this, "回声消除使能成功", Toast.LENGTH_SHORT)
                            .show();
                }
            }

            if (isNSAvailable()) {
                NoiseSuppressor noiseSuppressor = NoiseSuppressor
                        .create(mAudioRecord.getAudioSessionId());
                int resultCode = noiseSuppressor.setEnabled(true);
                if (AudioEffect.SUCCESS == resultCode) {
                    Toast.makeText(this, "噪声消除使能成功", Toast.LENGTH_SHORT)
                            .show();
                }
            }

            int trackBufferSizeInBytes = AudioTrack.getMinBufferSize(
                    sampleRateInHz, AudioFormat.CHANNEL_OUT_MONO,
                    AudioFormat.ENCODING_PCM_16BIT);
            mAudioTrackData = new short[trackBufferSizeInBytes];
            mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
                    sampleRateInHz, AudioFormat.CHANNEL_OUT_MONO,
                    AudioFormat.ENCODING_PCM_16BIT, trackBufferSizeInBytes,
                    AudioTrack.MODE_STREAM, mAudioRecord.getAudioSessionId());
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
    }

    /**
     * 判断回声消除是否可用
     */
    @SuppressLint("NewApi")
    private static boolean isAECAailable() {
        return AcousticEchoCanceler.isAvailable();
    }

    /**
     * 判断噪音抑制是否可用
     */
    @SuppressLint("NewApi")
    private static boolean isNSAvailable() {
        return NoiseSuppressor.isAvailable();
    }

    @Override
    protected void onStop() {
        Log.d(TAG, "onStop: ");
        
        if (mAudioFile != null && mAudioFile.exists()) {
            mAudioFile.delete();
        }
        if (mAudioRecord != null) {
            mAudioRecord.release();
            mAudioRecord = null;
        }
        if (mAudioTrack != null) {
            mAudioTrack.release();
            mAudioTrack = null;
        }
        super.onStop();
    }
}

manifests.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.aectest">

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>