Can anyone give code for voice recorder as an application on android phone? [closed]

Answer 1

You can write the actual recording code or you could leverage existing voice recorder application in your phone... Most phones have a default recorder app....

Call startActivityForResult with corresponding action. The following is the code.

Intent recordIntent = new Intent(MediaStore.Audio.Media.RECORD_SOUND_ACTION);
                startActivityForResult(recordIntent, REQUEST_CODE_RECORD);

Answer 2

Can you check this link:http://www.androiddevblog.net/android/android-audio-recording-part-1 and http://www.androiddevblog.net/android/android-audio-recording-part-2

Answer 3

So you want someone to actually post the whole code of the application you want to code?

Here it is, I guess.

Answer 4

Output:

MainActivity.java:

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.View;
import android.widget.Button;

/**
 * This class shows how to run Sound Recorder activity
 * @author The Developer's Info
 */
public class Main extends Activity {
    private static final int REQUEST_CODE_RECORD = 0;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Button startRecording = (Button) findViewById(R.id.startBtn);
        startRecording.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                Intent recordIntent = new Intent(
                        MediaStore.Audio.Media.RECORD_SOUND_ACTION);
                startActivityForResult(recordIntent, REQUEST_CODE_RECORD);

            }
        });
    }
}  

main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <Button
        android:id="@+id/startBtn"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/startBtnText" />

</LinearLayout>

Answer 5

There is an example of how to do audio capture using MediaRecorder in the Android Developer Documentation.

I would recommend saving the files on the SD Card and then have your gallery code check the SD card to see which files to display. You can get the directory of the SD Card using the Environment.getExternalStorageDirectory() method. It would be best to save your files in a subdirectory of the SD Card root directory.

Make sure you give your applications the Permissions it will need. At the very least it will need RECORD_AUDIO and WRITE_EXTERNAL_STORAGE.

Answer 6

If you want record the voice with clear clarity You should use the audio recorder...

The audio recorder implementation as follows..

     public static int datacount=1;
     private static final int RECORDER_BPP = 16;
      private static final String AUDIO_RECORDER_FILE_EXT_WAV = ".wav";
      private static final String AUDIO_RECORDER_FOLDER = "/'/'";
      private static final String AUDIO_RECORDER_TEMP_FILE = "record_temp.raw";
      private static final int RECORDER_SAMPLERATE = 44100;
      private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_STEREO;
      private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;

      private AudioRecord recorder = null;
      private int bufferSize = 0;
      private Thread recordingThread = null;
      private boolean isRecording = false;
      int numCrossing,p;

      public int frequency;





      public static File myfile;

      private Context mcontext;



      public static String final_sound_path=null;

      Handler handler;



      public static  String filename;


      public Taukyrecorder(Context cntxt) {
        // TODO Auto-generated constructor stub
          mcontext=cntxt;
          handler=new Handler();

          wave=new Taukywave(mcontext);






            bufferSize = AudioRecord.getMinBufferSize(RECORDER_SAMPLERATE,RECORDER_CHANNELS,RECORDER_AUDIO_ENCODING);

            recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
                    RECORDER_SAMPLERATE, RECORDER_CHANNELS,RECORDER_AUDIO_ENCODING, bufferSize);



            recorder.setRecordPositionUpdateListener(new OnRecordPositionUpdateListener() {

                @Override
                public void onPeriodicNotification(AudioRecord recorder) {
                    // TODO Auto-generated method stub

                }

                @Override
                public void onMarkerReached(AudioRecord recorder) {
                    // TODO Auto-generated method stub

                }
            }, handler);



    }






    //Get the file for saving sound into the folder
      public File GetFileTOwriteSound()
        {
            File tempPicFile=null;
            String ext_storage_state=Environment.getExternalStorageState();
            File mediaStorage=new File(Environment.getExternalStorageDirectory()+"/TAUKY/SOUNDS");
            if(ext_storage_state.equalsIgnoreCase(Environment.MEDIA_MOUNTED))
            {
                if(!mediaStorage.exists())
                {
                    mediaStorage.mkdirs();
                }else
                {
                    //do nothing
                }

                String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
                .format(new Date());
                tempPicFile = new File(mediaStorage.getPath() + File.separator
                        + "SOUND_" + timeStamp + ".wav");

            myfile=tempPicFile;

            }
            else
            {

                Toast.makeText(mcontext, "NO SDCARD MOUNTED", 1).show();

            }
            return tempPicFile;
        }







      public 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();

        return (file.getAbsolutePath() + "/" + AUDIO_RECORDER_TEMP_FILE);
      }

      public void startRecording(){


        recorder.startRecording();

        isRecording = true;



        recordingThread = new Thread(new Runnable() {

          @Override
          public void run() {
            writedataToFile();
          }
        },"AudioRecorder Thread");

        recordingThread.start();
      }

      private void writedataToFile(){
        final byte data[] = new byte[bufferSize];


        filename = getTempFilename();
        FileOutputStream os = null;



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







        if(null != os){
          while(isRecording){
            read = recorder.read(data, 0, bufferSize);


            wave.Updatewave(data);


//          new Thread(new Runnable() {
//              
//              @Override
//              public void run() {
//                  // TODO Auto-generated method stub
//                  
//                  for (int i = 0; i < read; i++) {
//                      
//                      sum +=data [i] * data [i];
//                  }
//                  if (read> 0) {
//                      final double amplitude = sum / read;
//                      //pb.setProgress((int) Math.sqrt(amplitude));
//                      
//                      wave.Updatewave(amplitude);
//                  }
//              
//                      
//                  
//              }
//          }).start();

            Log.i("recorder", "Recording");


            if(AudioRecord.ERROR_INVALID_OPERATION != read){
              try {
                os.write(data);




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



              numCrossing=0; //initialize your number of zero crossings to 0
              for (p=0;p<bufferSize/4;p+=4) {
                     if (data[p]>0 && data[p+1]<=0) numCrossing++;
                      if (data[p]<0 && data[p+1]>=0) numCrossing++;
                      if (data[p+1]>0 && data[p+2]<=0) numCrossing++;
                      if (data[p+1]<0 && data[p+2]>=0) numCrossing++;
                      if (data[p+2]>0 && data[p+3]<=0) numCrossing++;
                      if (data[p+2]<0 && data[p+3]>=0) numCrossing++;
                      if (data[p+3]>0 && data[p+4]<=0) numCrossing++;
                      if (data[p+3]<0 && data[p+4]>=0) numCrossing++;
                      }//for p

                for (p=(bufferSize/4)*4;p<bufferSize-1;p++) {
                      if (data[p]>0 && data[p+1]<=0) numCrossing++;
                      if (data[p]<0 && data[p+1]>=0) numCrossing++;
                      }



      frequency=(8000/bufferSize)*(numCrossing/2);  // Set the audio Frequency to half the number of zero crossings, times the number of samples our buffersize is per second.



      handler.post(new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
             //view.setText("Frequency is"+frequency);

        }
    });

            }
          }

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

      public void stopRecording(){
          String getfilename=GetFileTOwriteSound().getAbsolutePath();
          final_sound_path=getfilename;
        if(null != recorder){
          isRecording = false;

          recorder.stop();
          recorder.release();

          recorder = null;
          recordingThread = null;
        }

        copyWaveFile(getTempFilename(),getfilename);
        deleteTempFile();
      }

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

        file.delete();
      }

      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 = 2;
        long byteRate = RECORDER_BPP * RECORDER_SAMPLERATE * channels/8;

        byte[] data = new byte[bufferSize];

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

          ///AppLog.logString("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);
      }




}