class PlayAndRecordAudio
    {
        private const int RECORDER_BPP = 16;
        private const string AUDIO_RECORDER_FILE_EXT_WAV = ".wav";
        private const string AUDIO_RECORDER_TEMP_EXT = ".raw";
        private const int RECORDER_SAMPLERATE = 44100;

        private int _BufferSize;
        protected MediaPlayer _Player;
        protected AudioRecord _Recorder;
        private Thread recordingThread = null;
        private bool _IsRecording;
        public void StartPlayer()
        {
            var docsPath = CreatePathToFile(AUDIO_RECORDER_FILE_EXT_WAV);
            if (_Player == null)
            {
                _Player = new MediaPlayer();
            }
            _Player.Reset();
            _Player.SetDataSource(docsPath);
            _Player.Prepare();
            _Player.Start();
        }
        public void PausePlayer()
        {
            _Player.Pause();
        }
        public void StopPlayer()
        {
            _Player.Stop();
            _Player.Release();
            _Player = null;
        }
        public void StartRecord()
        {
            try
            {
                DelRecordFile(AUDIO_RECORDER_FILE_EXT_WAV);
                _BufferSize = AudioRecord.GetMinBufferSize(44100, ChannelIn.Stereo, Encoding.Pcm16bit);
                _Recorder = new AudioRecord(
                  // Hardware source of recording.
                  AudioSource.Mic,
                  // Frequency
                  44100,
                  // Mono or stereo
                  ChannelIn.Stereo,
                  // Audio encoding
                  Encoding.Pcm16bit,
                  // Length of the audio clip.
                  _BufferSize
                );
                AddEffects();
                _Recorder.StartRecording();
                _IsRecording = true;
                recordingThread = new Thread(new ThreadStart(WriteAudioDataToFile));
                recordingThread.Start();
            }
            catch (Exception ex)
            {
                System.Console.Out.WriteLine(ex.StackTrace);
            }
        }
        public void StopRecord()
        {
            // stops the recording activity
            if (_Recorder != null)
            {
                _IsRecording = false;

                _Recorder.Stop();
                _Recorder.Release();

                _Recorder = null;
                recordingThread = null;
            }
            copyWaveFile(CreatePathToFile(AUDIO_RECORDER_TEMP_EXT),
                CreatePathToFile(AUDIO_RECORDER_FILE_EXT_WAV));

            //del tmp file
            DelRecordFile(AUDIO_RECORDER_TEMP_EXT);
        }
        private void AddEffects()
        {
            if (NoiseSuppressor.IsAvailable)
            {
                NoiseSuppressor.Create(_Recorder.AudioSessionId);
            }
            if (AcousticEchoCanceler.IsAvailable)
            {
                AcousticEchoCanceler.Create(_Recorder.AudioSessionId);
            }
        }
        private byte[] Short2Byte(short[] sData)
        {
            int shortArrsize = sData.Length;
            byte[] bytes = new byte[shortArrsize * 2];

            for (int i = 0; i < shortArrsize; i++)
            {
                bytes[i * 2] = (byte)(sData[i] & 0x00FF);
                bytes[(i * 2) + 1] = (byte)(sData[i] >> 8);
                sData[i] = 0;
            }
            return bytes;

        }
        private void WriteAudioDataToFile()
        {
            // Write the output audio in byte
            string filePath = CreatePathToFile(AUDIO_RECORDER_TEMP_EXT);
            short[] sData = new short[_BufferSize];

            FileOutputStream os = null;
            try
            {
                os = new FileOutputStream(filePath);
            }
            catch (FileNotFoundException e)
            {
                System.Console.Out.WriteLine(e.Message);
            }

            while (_IsRecording)
            {
                // gets the voice output from microphone to byte format

                _Recorder.Read(sData, 0, _BufferSize);
                try
                {
                    // // writes the data to file from buffer
                    // // stores the voice buffer

                    byte[] bData = Short2Byte(sData);

                    os.Write(bData);
                }
                catch (IOException e)
                {
                    System.Console.Out.WriteLine(e.StackTrace); ;
                }
            }
            try
            {
                os.Close();
            }
            catch (IOException e)
            {
                System.Console.Out.WriteLine(e.StackTrace);
            }
        }
        private void copyWaveFile(string inFilename, string outFilename)
        {
            FileInputStream input = null;
            FileOutputStream output = 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
            {
                input = new FileInputStream(inFilename);
                output = new FileOutputStream(outFilename);
                totalAudioLen = input.Channel.Size();
                totalDataLen = totalAudioLen + 36;
                WriteWaveFileHeader(output, totalAudioLen, totalDataLen,
                                longSampleRate, channels, byteRate);

                while (input.Read(data) != -1){
                    output.Write(data);
                }

                input.Close();
                output.Close();
            }
            catch (FileNotFoundException e)
            {
                System.Console.Out.WriteLine(e.StackTrace);
            }
            catch (IOException e)
            {
                System.Console.Out.WriteLine(e.StackTrace);
            }
        }
        private void WriteWaveFileHeader(
                        FileOutputStream @out, long totalAudioLen,
                        long totalDataLen, long longSampleRate, int channels,
                        long byteRate)
        {
            byte[] header = new byte[44];
            header[0] = Convert.ToByte('R');  // RIFF/WAVE header
            header[1] = Convert.ToByte('I');
            header[2] = Convert.ToByte('F');
            header[3] = Convert.ToByte('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] = Convert.ToByte('W');
            header[9] = Convert.ToByte('A');
            header[10] = Convert.ToByte('V');
            header[11] = Convert.ToByte('E');
            header[12] = Convert.ToByte('f');  // 'fmt ' chunk
            header[13] = Convert.ToByte('m');
            header[14] = Convert.ToByte('t');
            header[15] = Convert.ToByte(' ');
            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] = Convert.ToByte('d');
            header[37] = Convert.ToByte('a');
            header[38] = Convert.ToByte('t');
            header[39] = Convert.ToByte('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);
        }
        private void DelRecordFile(string extension)
        {
            File file = new File(CreatePathToFile(extension));
            if (file != null)
            {
                file.Delete();
            }
        }
        string CreatePathToFile(string extension)
        {
            var docsPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
            return System.IO.Path.Combine(docsPath, "tmp" + extension);
        }

    }