AudioRecord/AudioTrack-UsingBuffer

/** Record and Playback using a single buffer, running in a thread
Code written on : Aug 27th 2014
**/


public class BufferMain extends ActionBarActivity
{
    private String TAG = "AUDIO_RECORD_PLAYBACK_SAURABH_BUFFER";
    private boolean isRunning = true;

    private Thread m_thread;

    private AudioRecord recorder = null;
    private AudioTrack track = null;

    byte buffer[] = new byte[640];
    int bufferSize;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_buffer_main);

        enableButton(R.id.StartButton,true);
        enableButton(R.id.StopButton,false);

        /* Assign Button Click Handlers */
        ((Button)findViewById(R.id.StartButton)).setOnClickListener(btnClick);
        ((Button)findViewById(R.id.StopButton)).setOnClickListener(btnClick);

        /*if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                    .add(R.id.container, new PlaceholderFragment()).commit();
        }*/
        Log.d(TAG, "\n\n\n\n\n\n============================= Starting Application.. =====================================");
    }

    private View.OnClickListener btnClick = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            switch(v.getId()){
            case R.id.StartButton:
            {
                Log.d(TAG, "==========================================Start Recording==========================================");
                isRunning = true;
                Log.d(TAG, "========== isRunning = true =============");
                do_loopback(isRunning);
                enableButton(R.id.StartButton,false);
                enableButton(R.id.StopButton,true);
                break;
            }
            case R.id.StopButton:
            {
                Log.d(TAG, "==========================================Stop Recording==========================================");
                isRunning = false;
                Log.d(TAG, "========== isRunning = false =============");
                do_loopback(isRunning);
                enableButton(R.id.StopButton,false);
                enableButton(R.id.StartButton,true);
                break;
            }
            }
        }
    };
public void run_loop (boolean isRunning)
    {
        int readbytes, writebytes, state;
        Log.d(TAG, "===== Entering run Loop ===== ");
        bufferSize = 640;

        recorder = findAudioRecord(recorder);
        if (recorder == null) {
            Log.e(TAG, "=============================== findAudioRecord : Returned Error! =============================== ");
            return;
        }

        track = findAudioTrack(track);
        if (track == null) {
            Log.e(TAG, "=============================== findAudioTrack : Returned Error! =============================== ");
            return;
        }

        if ((AudioRecord.STATE_INITIALIZED == recorder.getState()) && (AudioTrack.STATE_INITIALIZED == track.getState()))
        {
            recorder.startRecording();
            Log.d(TAG, "========= recorder Started... =========");
            track.play();
            Log.d(TAG, "========= Track Started... =========");
        } else {
            Log.d(TAG, "========= Initilazation failed for AudioRecord or AudioTrack =========");
            return;
        }

        while (isRunning) {
            readbytes = 0;                                              /* Reset read bytes for next Iteration */
            writebytes = 0;                                             /* Reset write bytes for next Iteration */

            readbytes = recorder.read(buffer, 0, bufferSize);
            if(-1 == checkAudioRecordforError(readbytes))               /* Error Checking Code for AudioRecord */
            {
                Log.d(TAG, "========= Read Error =========");
                return;
            }

            writebytes = track.write(buffer, 0, bufferSize);
            if (-1 == checkAudioTrackforError(writebytes))              /* Error Checking Code for AudioRecord */
            {
                Log.d(TAG, "========= Write Error =========");
                return;
            }
        }
        Log.i(TAG, "loopback exit");
    return ;
}



public AudioTrack findAudioTrack (AudioTrack track)
    {
        Log.d(TAG, "=============================== Initialising Playing API ===============================");

        bufferSize = AudioTrack.getMinBufferSize(8000,
                AudioFormat.CHANNEL_OUT_MONO,
                AudioFormat.ENCODING_PCM_16BIT);        /* Return 640 */

        /** Overriding bufferSize value of 640 with 320**/
        Log.d(TAG, "========= BEFORE AudioTrack ==> bufferSize : "+bufferSize+"=========");
        //bufferSize = 320;
        //Log.d(TAG, "========= AudioTrack ==> bufferSize : "+bufferSize+"=========");

        if (bufferSize != AudioTrack.ERROR_BAD_VALUE)
        {
            track = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,
                    AudioFormat.CHANNEL_OUT_MONO,
                    AudioFormat.ENCODING_PCM_16BIT, bufferSize,
                    AudioTrack.MODE_STREAM);

            int type = track.getStreamType();
            Log.d(TAG, "========= AudioTrack ==> getStreamType : "+type+"====");

            if (track.getState() == AudioTrack.STATE_UNINITIALIZED) {
                Log.e(TAG, "=============================== AudioTrack UnInitilaised =============================== ");
                return null;
            }
        }
        return track;
    }


    public AudioRecord findAudioRecord (AudioRecord recorder)
    {
        Log.d(TAG, "=============================== Initialising Record API ===============================");
        bufferSize = AudioRecord.getMinBufferSize(8000,
                AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_PCM_16BIT);

        /** Overriding bufferSize value of 640 with 320**/
        //Log.d(TAG, "========= BEFORE AudioRecord ==> bufferSize : "+bufferSize+"=========");
        //bufferSize = 320;
        Log.d(TAG, "========= AudioRecord ==> bufferSize : "+bufferSize+"=========");

        if (bufferSize != AudioRecord.ERROR_BAD_VALUE)
        {
            recorder = new AudioRecord(AudioSource.DEFAULT, 8000,
                    AudioFormat.CHANNEL_IN_MONO,
                    AudioFormat.ENCODING_PCM_16BIT, bufferSize);

            if (recorder.getState() == AudioRecord.STATE_UNINITIALIZED) {
                Log.e(TAG, "=============================== AudioRecord UnInitilaised =============================== ");
                return null;
            }
        }
        Log.d(TAG, "=============================== Initialising Record Completed ===============================");
        return recorder;
    }

    public int checkAudioRecordforError(int readbytes)
    {
        if (readbytes ==  recorder.ERROR_INVALID_OPERATION || readbytes ==  recorder.ERROR_BAD_VALUE)
        {
            if(readbytes == AudioRecord.ERROR_INVALID_OPERATION)
                Log.d(TAG, "========= read Error : ERROR_INVALID_OPERATION ===========");
            else if (readbytes == AudioRecord.ERROR_BAD_VALUE)
                Log.d(TAG, "========= read Error : ERROR_BAD_VALUE ===========");
            else if (readbytes == AudioRecord.ERROR)
                Log.d(TAG, "========= read Error : ERROR Unknown ===========");
            return -1;
        }
        return readbytes;
    }

    public int checkAudioTrackforError(int writebytes)
    {
        if (writebytes ==  track.ERROR_INVALID_OPERATION || writebytes ==  track.ERROR_BAD_VALUE)
        {
            if(writebytes == track.ERROR_INVALID_OPERATION)
                Log.d(TAG, "========= read Error : ERROR_INVALID_OPERATION ===========");
            else if (writebytes == track.ERROR_BAD_VALUE)
                Log.d(TAG, "========= read Error : ERROR_BAD_VALUE ===========");
            else if (writebytes == track.ERROR)
                Log.d(TAG, "========= read Error : ERROR Unknown ===========");
            return -1;
        }
        return writebytes;
    }

    private void do_loopback(final boolean flag) {
        Log.d(TAG, "========== within do_loopback ============");
        m_thread = new Thread(new Runnable() {
            public void run() {
                run_loop(flag);
            }
        });
        m_thread.start();
    }

    /* Function to Enable/Disable Buttons */
    private void enableButton(int id,boolean isEnable){
        ((Button)findViewById(id)).setEnabled(isEnable);
    }
}