AudioRecord/AudioTrack-UsingFile27thAug2014

package com.example.audiorecplayfinalaug14;


/* This Program is used to Record and Play back Some audio
 * The Recorded Audio is written to a file, and same file is used during Play back

Code written on : Aug 27th 2014
 * */

import java.io.DataInputStream;
import java.util.Arrays;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.sql.Date;
import java.text.SimpleDateFormat;
import java.util.Calendar;

import android.support.v7.app.ActionBarActivity;
import android.support.v7.app.ActionBar;
import android.support.v4.app.Fragment;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaCodecInfo.CodecCapabilities;
import android.media.MediaRecorder.AudioEncoder;
import android.media.MediaRecorder.AudioSource;
import android.net.rtp.AudioCodec;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.os.Build;

public class Main extends ActionBarActivity {

    private static int[] mSampleRates = new int[] { 8000, 11025, 22050, 44100 };

    private String TAG = "AUDIO_RECORD_PLAYBACK_SAURABH";
    private static final int RECORDER_BPP = 16;
    private static final String AUDIO_RECORDER_FILE_EXT_WAV = ".wav";
    private static final String AUDIO_RECORDER_FOLDER = "AudioRecorder";
    private static final String AUDIO_RECORDER_TEMP_FILE = "record_temp.raw";
    private static final int RECORDER_SAMPLERATE = 8000;
    private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_MONO;
    private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;

    private AudioRecord recorder = null;
    private AudioCodec codec = AudioCodec.getCodec(100, "AMR/8000", "mode-set=1");

    private int bufferSize = 0;

    /* Threads for Recording/Playing */
    private Thread recordingThread = null;
    //private Thread playingThread = null;

    /* Flags for Recording/Playing */
    private boolean isRecording = false;
    //private boolean isPlaying = false;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d(TAG, "\n\n\n\n======================= Starting Application now =======================");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        setButtonHandlers();

        enableButton(R.id.btnStartRec,true);
        enableButton(R.id.btnStopRec,false);

        enableButton(R.id.btnStartPlay,false);
        enableButton(R.id.btnStopPlay,false);

        bufferSize = AudioRecord.getMinBufferSize(8000,
                AudioFormat.CHANNEL_IN_DEFAULT,
                AudioFormat.ENCODING_PCM_16BIT);        /* Return 640 */

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

        AudioCodec arr[] = codec.getCodecs();
        Log.d(TAG, "Supported Codecs :" +Arrays.toString(arr) +"\n");

        /*if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
            .add(R.id.container, new PlaceholderFragment()).commit();
        }*/
    }

    private void startRecording()
    {
        recorder = findAudioRecord();
        int i = recorder.getState();
        if(i==1)
            recorder.startRecording();

        isRecording = true;
        recordingThread = new Thread(new Runnable() {
            @Override
            public void run() {
                writeAudioDataToFile();
            }
        },"AudioRecorder Thread");
        recordingThread.start();
    }

    private void stopRecording(){
        if(null != recorder){
            isRecording = false;

            int i = recorder.getState();
            if(i==1)
                recorder.stop();
            recorder.release();
            Log.d(TAG, "===== Recording Audio Completed ===== ");

            recorder = null;
            recordingThread = null;
        }

        //copyWaveFile(getTempFilename(), getFilename());
        //deleteTempFile();
    }

    public void StartPlaying()
    {
        int minBufferSize = AudioTrack.getMinBufferSize(8000,
                AudioFormat.CHANNEL_OUT_MONO,
                AudioFormat.ENCODING_PCM_16BIT);        /* Return 640 */

        /** Overriding bufferSize value of 640 with 320**/
        minBufferSize = 320;

        Log.d(TAG, "===== StartPlaying ==> Value of  minBufferSize : ["+minBufferSize+"] ===== ");
        int bufferSize = minBufferSize;
        AudioTrack at = new AudioTrack(AudioManager.STREAM_MUSIC, 8000, AudioFormat.CHANNEL_OUT_MONO,
                //AudioFormat.ENCODING_PCM_16BIT, minBufferSize, AudioTrack.MODE_STREAM);
                AudioFormat.ENCODING_PCM_16BIT, bufferSize, AudioTrack.MODE_STREAM);

        int i = 0;
        byte[] temp = new byte[bufferSize];
        try {
            //FileInputStream fin = new FileInputStream("/sdcard/AudioRecorder/audiofile.wav");
            //Log.d(TAG, "===== opening file : /sdcard/AudioRecorder/audiofile.wav ===== ");

            FileInputStream fin = new FileInputStream(raw_filename);
            Log.d(TAG, "===== Opening file : "+raw_filename+" ===== ");

            DataInputStream dis = new DataInputStream(fin);

            SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SS");
            Calendar cal = Calendar.getInstance();
            String strDate = s.format(cal.getTime());

            at.play();
            while((i = dis.read(temp, 0, bufferSize)) > -1)
            {
                cal = Calendar.getInstance();
                strDate = s.format(cal.getTime());
                Log.e(TAG, "================== Buffer before Playing ===================="+Arrays.toString(temp));
                at.write(temp, 0, i);
                Log.e(TAG, "================== Buffer after Playing ===================="+Arrays.toString(temp));
                Log.d(TAG, "===== Playing Audio ===== Time :"+strDate);
            }

            Log.d(TAG, "===== Playing Audio Completed ===== ");
            at.stop();
            at.release();
            dis.close();
            fin.close();

        } catch (FileNotFoundException e) {
            // TODO
            e.printStackTrace();
        } catch (IOException e) {
            // TODO
            e.printStackTrace();
        }
    }

    private void writeAudioDataToFile()
    {
        byte data[] = new byte[bufferSize];
        String filename = getTempFilename();
        FileOutputStream os = null;

        try {
            os = new FileOutputStream(filename);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        int read = 0;

        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SS");
        Calendar cal = Calendar.getInstance();
        String strDate = s.format(cal.getTime());

        if(null != os){
            while(isRecording){

                /* Printing Time Stamp */
                Log.e(TAG, "================== Buffer Before Reading ===================="+Arrays.toString(data));
                read = recorder.read(data, 0, bufferSize);
                Log.e(TAG, "================== Buffer After Reading ===================="+Arrays.toString(data));

                cal = Calendar.getInstance();
                strDate = s.format(cal.getTime());
                Log.d(TAG, "===== Recording Audio ===== Time :"+strDate);

                if(AudioRecord.ERROR_INVALID_OPERATION != read){
                    try {
                        os.write(data);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private String getFilename(){
        String filepath = Environment.getExternalStorageDirectory().getPath();
        File file = new File(filepath,AUDIO_RECORDER_FOLDER);

        if(!file.exists()){
            file.mkdirs();
        }
        return (file.getAbsolutePath() + "/" + "audiofile" + AUDIO_RECORDER_FILE_EXT_WAV);
    }

    private String raw_filename = null;

    private String getTempFilename(){
        String filepath = Environment.getExternalStorageDirectory().getPath();
        File file = new File(filepath,AUDIO_RECORDER_FOLDER);

        if(!file.exists()){
            file.mkdirs();
        }

        File tempFile = new File(filepath,AUDIO_RECORDER_TEMP_FILE);

        //if(tempFile.exists())
        //  tempFile.delete();

        raw_filename = file.getAbsolutePath() + "/" + AUDIO_RECORDER_TEMP_FILE;
        Log.d(TAG, "================= Temp File Name : "+file.getAbsolutePath() + "/" + AUDIO_RECORDER_TEMP_FILE+"=================");
        return (file.getAbsolutePath() + "/" + AUDIO_RECORDER_TEMP_FILE);
    }

    private void copyWaveFile(String inFilename,String outFilename){
        FileInputStream in = null;
        FileOutputStream out = null;
        long totalAudioLen = 0;
        long totalDataLen = totalAudioLen + 36;
        long longSampleRate = RECORDER_SAMPLERATE;
        int channels = 1;
        long byteRate = (RECORDER_BPP/8) * RECORDER_SAMPLERATE * channels;

        byte[] data = new byte[bufferSize];

        try {
            in = new FileInputStream(inFilename);
            out = new FileOutputStream(outFilename);
            totalAudioLen = in.getChannel().size();
            totalDataLen = totalAudioLen + 36;

            Log.d(TAG, "File size: " + totalDataLen);

            WriteWaveFileHeader(out, totalAudioLen, totalDataLen,
                    longSampleRate, channels, byteRate);

            while(in.read(data) != -1){
                out.write(data);
            }
            in.close();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void WriteWaveFileHeader(
            FileOutputStream out, long totalAudioLen,
            long totalDataLen, long longSampleRate, int channels,
            long byteRate) throws IOException {

        byte[] header = new byte[44];

        header[0] = 'R';  // RIFF/WAVE header
        header[1] = 'I';
        header[2] = 'F';
        header[3] = 'F';
        header[4] = (byte) (totalDataLen & 0xff);
        header[5] = (byte) ((totalDataLen >> 8) & 0xff);
        header[6] = (byte) ((totalDataLen >> 16) & 0xff);
        header[7] = (byte) ((totalDataLen >> 24) & 0xff);
        header[8] = 'W';
        header[9] = 'A';
        header[10] = 'V';
        header[11] = 'E';
        header[12] = 'f';  // 'fmt ' chunk
        header[13] = 'm';
        header[14] = 't';
        header[15] = ' ';
        header[16] = 16;  // 4 bytes: size of 'fmt ' chunk
        header[17] = 0;
        header[18] = 0;
        header[19] = 0;
        header[20] = 1;  // format = 1
        header[21] = 0;
        header[22] = (byte) channels;
        header[23] = 0;
        header[24] = (byte) (longSampleRate & 0xff);
        header[25] = (byte) ((longSampleRate >> 8) & 0xff);
        header[26] = (byte) ((longSampleRate >> 16) & 0xff);
        header[27] = (byte) ((longSampleRate >> 24) & 0xff);
        header[28] = (byte) (byteRate & 0xff);
        header[29] = (byte) ((byteRate >> 8) & 0xff);
        header[30] = (byte) ((byteRate >> 16) & 0xff);
        header[31] = (byte) ((byteRate >> 24) & 0xff);
        header[32] = (byte) (2 * 16 / 8);  // block align
        header[33] = 0;
        header[34] = RECORDER_BPP;  // bits per sample
        header[35] = 0;
        header[36] = 'd';
        header[37] = 'a';
        header[38] = 't';
        header[39] = 'a';
        header[40] = (byte) (totalAudioLen & 0xff);
        header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
        header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
        header[43] = (byte) ((totalAudioLen >> 24) & 0xff);

        out.write(header, 0, 44);
    }

    /* Method will attempt to find correct combination of Audio Configuration, by attempting
     * different combinations of Sampling rate, channel configuration and encoding_types */
    public AudioRecord findAudioRecord()
    {
        for (int rate : mSampleRates) {
            for (short audioFormat : new short[] { AudioFormat.ENCODING_PCM_8BIT, AudioFormat.ENCODING_PCM_16BIT }) {
                for (short channelConfig : new short[] { AudioFormat.CHANNEL_IN_MONO, AudioFormat.CHANNEL_IN_STEREO }) {
                    try {
                        Log.d(TAG, "Attempting rate " + rate + "Hz, bits: " + audioFormat + ", channel: "
                                + channelConfig);
                        int bufferSize = AudioRecord.getMinBufferSize(rate, channelConfig, audioFormat);

                        if (bufferSize != AudioRecord.ERROR_BAD_VALUE) {
                            // check if we can instantiate and have a success
                            AudioRecord recorder = new AudioRecord(AudioSource.DEFAULT, rate, channelConfig, audioFormat, bufferSize);

                            if (recorder.getState() == AudioRecord.STATE_INITIALIZED) {
                                Log.d(TAG, "================== Final Values: rate " + rate + "Hz, audioFormat: " + audioFormat + ", channel: "
                                        + channelConfig+" ==================");
                                return recorder;
                            }
                        }
                    } catch (Exception e) {
                        Log.e(TAG, rate + "Exception, keep trying.",e);
                    }
                }
            }
        }
        return null;
    }

    private void deleteTempFile() {
        File file = new File(getTempFilename());
        file.delete();
    }

    private View.OnClickListener btnClick = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            switch(v.getId()){
            case R.id.btnStartRec:{
                Log.d(TAG, "Start Recording");
                enableButton(R.id.btnStartRec,false);
                enableButton(R.id.btnStopRec,true);
                startRecording();
                enableButton(R.id.btnStopPlay,false);
                break;
            }
            case R.id.btnStopRec:{
                Log.d(TAG, "Stop Recording");
                enableButton(R.id.btnStartRec,true);
                enableButton(R.id.btnStopRec,false);
                stopRecording();
                enableButton(R.id.btnStartPlay,true);
                break;
            }
            case R.id.btnStartPlay:{
                Log.d(TAG, "Play Recording");
                enableButton(R.id.btnStartRec,false);
                enableButton(R.id.btnStopRec,false);
                StartPlaying();
                enableButton(R.id.btnStartPlay,false);
                enableButton(R.id.btnStopPlay,true);
                break;
            }

            case R.id.btnStopPlay:{
                Log.d(TAG, "Stop Playing");
                //StopPlaying();
                enableButton(R.id.btnStartPlay,true);
                enableButton(R.id.btnStopPlay,false);
                enableButton(R.id.btnStartRec,true);
                break;
            }
            }
        }
    };

    /* Assign OnClickListener to Buttons */
    private void setButtonHandlers() {
        ((Button)findViewById(R.id.btnStartRec)).setOnClickListener(btnClick);
        ((Button)findViewById(R.id.btnStopRec)).setOnClickListener(btnClick);
        ((Button)findViewById(R.id.btnStartPlay)).setOnClickListener(btnClick);
        ((Button)findViewById(R.id.btnStopPlay)).setOnClickListener(btnClick);
    }

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

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    /**
     * A placeholder fragment containing a simple view.
     */
    public static class PlaceholderFragment extends Fragment {

        public PlaceholderFragment() {
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                Bundle savedInstanceState) {
            View rootView = inflater.inflate(R.layout.fragment_main, container,
                    false);
            return rootView;
        }
    }

}