/*
 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
 *
 * Use of this source code is governed by a BSD-style license that can be found
 * in the LICENSE file in the root of the source tree. An additional
 * intellectual property rights grant can be found in the file PATENTS. All
 * contributing project authors may be found in the AUTHORS file in the root of
 * the source tree.
 */

/*
 * VoiceEngine Android test application. It starts either auto test or acts like
 * a GUI test.
 */

package org.webrtc.voiceengine.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;

import android.app.Activity;
import android.content.Context;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TextView;

public class AndroidTest extends Activity {
    private byte[] _playBuffer = null;
    private short[] _circBuffer = new short[8000]; // can hold 50 frames

    private int _recIndex = 0;
    private int _playIndex = 0;
    // private int _streamVolume = 4;
    private int _maxVolume = 0; // Android max level (commonly 5)
    // VoE level (0-255), corresponds to level 4 out of 5
    private int _volumeLevel = 204;

    private Thread _playThread;
    private Thread _recThread;
    private Thread _autotestThread;

    private static AudioTrack _at;
    private static AudioRecord _ar;

    private File _fr = null;
    private FileInputStream _in = null;

    private boolean _isRunningPlay = false;
    private boolean _isRunningRec = false;
    private boolean _settingSet = true;
    private boolean _isCallActive = false;
    private boolean _runAutotest = false; // ENABLE AUTOTEST HERE!

    private int _channel = -1;
    private int _codecIndex = 0;
    private int _ecIndex = 0;
    private int _nsIndex = 0;
    private int _agcIndex = 0;
    private int _vadIndex = 0;
    private int _audioIndex = 3;
    private int _settingMenu = 0;
    private int _receivePort = 1234;
    private int _destinationPort = 1234;
    private String _destinationIP = "127.0.0.1";

    // "Build" settings
    private final boolean _playFromFile = false;
    // Set to true to send data to native code and back
    private final boolean _runThroughNativeLayer = true;
    private final boolean enableSend = true;
    private final boolean enableReceive = true;
    private final boolean useNativeThread = false;

    /** Called when the activity is first created. */
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        TextView tv = (TextView) findViewById(R.id.TextView01);
        tv.setText("");

        final EditText ed = (EditText) findViewById(R.id.EditText01);
        ed.setWidth(200);
        ed.setText(_destinationIP);

        final Button buttonStart = (Button) findViewById(R.id.Button01);
        buttonStart.setWidth(200);
        if (_runAutotest) {
            buttonStart.setText("Run test");
        } else {
            buttonStart.setText("Start Call");
        }
        // button.layout(50, 50, 100, 40);
        buttonStart.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {

                if (_runAutotest) {
                    startAutoTest();
                } else {
                    if (_isCallActive) {

                        if (stopCall() != -1) {
                            _isCallActive = false;
                            buttonStart.setText("Start Call");
                        }
                    } else {

                        _destinationIP = ed.getText().toString();
                        if (startCall() != -1) {
                            _isCallActive = true;
                            buttonStart.setText("Stop Call");
                        }
                    }
                }

                // displayTextFromFile();
                // recordAudioToFile();
                // if(!_playFromFile)
                // {
                // recAudioInThread();
                // }
                // playAudioInThread();
            }
        });

        final Button buttonStop = (Button) findViewById(R.id.Button02);
        buttonStop.setWidth(200);
        buttonStop.setText("Close app");
        buttonStop.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {

                if (!_runAutotest) {
                    ShutdownVoE();
                }

                // This call terminates and should close the activity
                finish();

                // playAudioFromFile();
                // if(!_playFromFile)
                // {
                // stopRecAudio();
                // }
                // stopPlayAudio();
            }
        });


        String ap1[] = {"EC off", "AECM"};
        final ArrayAdapter<String> adapterAp1 = new ArrayAdapter<String>(
                        this,
                        android.R.layout.simple_spinner_dropdown_item,
                        ap1);
        String ap2[] =
                        {"NS off", "NS low", "NS moderate", "NS high",
                                        "NS very high"};
        final ArrayAdapter<String> adapterAp2 = new ArrayAdapter<String>(
                        this,
                        android.R.layout.simple_spinner_dropdown_item,
                        ap2);
        String ap3[] = {"AGC off", "AGC adaptive", "AGC fixed"};
        final ArrayAdapter<String> adapterAp3 = new ArrayAdapter<String>(
                        this,
                        android.R.layout.simple_spinner_dropdown_item,
                        ap3);
        String ap4[] =
                        {"VAD off", "VAD conventional", "VAD high rate",
                                        "VAD mid rate", "VAD low rate"};
        final ArrayAdapter<String> adapterAp4 = new ArrayAdapter<String>(
                        this,
                        android.R.layout.simple_spinner_dropdown_item,
                        ap4);
        String codecs[] = {"iSAC", "PCMU", "PCMA", "iLBC"};
        final ArrayAdapter<String> adapterCodecs = new ArrayAdapter<String>(
                        this,
                        android.R.layout.simple_spinner_dropdown_item,
                        codecs);

        final Spinner spinnerSettings1 = (Spinner) findViewById(R.id.Spinner01);
        final Spinner spinnerSettings2 = (Spinner) findViewById(R.id.Spinner02);
        spinnerSettings1.setMinimumWidth(200);
        String settings[] =
                        {"Codec", "Echo Control", "Noise Suppression",
                         "Automatic Gain Control",
                         "Voice Activity Detection"};
        ArrayAdapter<String> adapterSettings1 = new ArrayAdapter<String>(
                        this,
                        android.R.layout.simple_spinner_dropdown_item,
                        settings);
        spinnerSettings1.setAdapter(adapterSettings1);
        spinnerSettings1.setOnItemSelectedListener(
                        new AdapterView.OnItemSelectedListener() {
            public void onItemSelected(AdapterView adapterView, View view,
                            int position, long id) {

                _settingMenu = position;
                _settingSet = false;
                if (position == 0) {
                    spinnerSettings2.setAdapter(adapterCodecs);
                    spinnerSettings2.setSelection(_codecIndex);
                }
                if (position == 1) {
                    spinnerSettings2.setAdapter(adapterAp1);
                    spinnerSettings2.setSelection(_ecIndex);
                }
                if (position == 2) {
                    spinnerSettings2.setAdapter(adapterAp2);
                    spinnerSettings2.setSelection(_nsIndex);
                }
                if (position == 3) {
                    spinnerSettings2.setAdapter(adapterAp3);
                    spinnerSettings2.setSelection(_agcIndex);
                }
                if (position == 4) {
                    spinnerSettings2.setAdapter(adapterAp4);
                    spinnerSettings2.setSelection(_vadIndex);
                }
            }

            public void onNothingSelected(AdapterView adapterView) {
                WebrtcLog("No setting1 selected");
            }
        });

        spinnerSettings2.setMinimumWidth(200);
        ArrayAdapter<String> adapterSettings2 = new ArrayAdapter<String>(
                        this,
                        android.R.layout.simple_spinner_dropdown_item,
                        codecs);
        spinnerSettings2.setAdapter(adapterSettings2);
        spinnerSettings2.setOnItemSelectedListener(
                        new AdapterView.OnItemSelectedListener() {
            public void onItemSelected(AdapterView adapterView, View view,
                            int position, long id) {

                // avoid unintentional setting
                if (_settingSet == false) {
                    _settingSet = true;
                    return;
                }

                // Change volume
                if (_settingMenu == 0) {
                    WebrtcLog("Selected audio " + position);
                    setAudioProperties(position);
                    spinnerSettings2.setSelection(_audioIndex);
                }

                // Change codec
                if (_settingMenu == 1) {
                    _codecIndex = position;
                    WebrtcLog("Selected codec " + position);
                    if (0 != SetSendCodec(_channel, _codecIndex)) {
                        WebrtcLog("VoE set send codec failed");
                    }
                }

                // Change EC
                if (_settingMenu == 2) {
                    boolean enable = true;
                    int ECmode = 5; // AECM
                    int AESmode = 0;

                    _ecIndex = position;
                    WebrtcLog("Selected EC " + position);

                    if (position == 0) {
                        enable = false;
                    }
                    if (position > 1) {
                        ECmode = 4; // AES
                        AESmode = position - 1;
                    }

                    if (0 != SetECStatus(enable, ECmode)) {
                        WebrtcLog("VoE set EC status failed");
                    }
                }

                // Change NS
                if (_settingMenu == 3) {
                    boolean enable = true;

                    _nsIndex = position;
                    WebrtcLog("Selected NS " + position);

                    if (position == 0) {
                        enable = false;
                    }
                    if (0 != SetNSStatus(enable, position + 2)) {
                        WebrtcLog("VoE set NS status failed");
                    }
                }

                // Change AGC
                if (_settingMenu == 4) {
                    boolean enable = true;

                    _agcIndex = position;
                    WebrtcLog("Selected AGC " + position);

                    if (position == 0) {
                        enable = false;
                        position = 1; // default
                    }
                    if (0 != SetAGCStatus(enable, position + 2)) {
                        WebrtcLog("VoE set AGC status failed");
                    }
                }

                // Change VAD
                if (_settingMenu == 5) {
                    boolean enable = true;

                    _vadIndex = position;
                    WebrtcLog("Selected VAD " + position);

                    if (position == 0) {
                        enable = false;
                        position++;
                    }
                    if (0 != SetVADStatus(_channel, enable, position - 1)) {
                        WebrtcLog("VoE set VAD status failed");
                    }
                }
            }

            public void onNothingSelected(AdapterView adapterView) {
            }
        });

        // Setup VoiceEngine
        if (!_runAutotest && !useNativeThread) SetupVoE();

        // Suggest to use the voice call audio stream for hardware volume
        // controls
        setVolumeControlStream(AudioManager.STREAM_VOICE_CALL);

        // Get max Android volume and adjust default volume to map exactly to an
        // Android level
        AudioManager am =
                        (AudioManager) getSystemService(Context.AUDIO_SERVICE);
        _maxVolume = am.getStreamMaxVolume(AudioManager.STREAM_VOICE_CALL);
        if (_maxVolume <= 0) {
            WebrtcLog("Could not get max volume!");
        } else {
            int androidVolumeLevel = (_volumeLevel * _maxVolume) / 255;
            _volumeLevel = (androidVolumeLevel * 255) / _maxVolume;
        }

        WebrtcLog("Started Webrtc Android Test");
    }

    // Will be called when activity is shutdown.
    // NOTE: Activity may be killed without this function being called,
    // but then we should not need to clean up.
    protected void onDestroy() {
        super.onDestroy();
        // ShutdownVoE();
    }

    private void SetupVoE() {
        // Create VoiceEngine
        Create(); // Error logging is done in native API wrapper

        // Initialize
        if (0 != Init(false, false)) {
            WebrtcLog("VoE init failed");
        }

        // Create channel
        _channel = CreateChannel();
        if (0 != _channel) {
            WebrtcLog("VoE create channel failed");
        }

    }

    private void ShutdownVoE() {
        // Delete channel
        if (0 != DeleteChannel(_channel)) {
            WebrtcLog("VoE delete channel failed");
        }

        // Terminate
        if (0 != Terminate()) {
            WebrtcLog("VoE terminate failed");
        }

        // Delete VoiceEngine
        Delete(); // Error logging is done in native API wrapper
    }

    int startCall() {

        if (useNativeThread == true) {

            Create();
            return 0;
        }

        if (enableReceive == true) {
            // Set local receiver
            if (0 != SetLocalReceiver(_channel, _receivePort)) {
                WebrtcLog("VoE set local receiver failed");
            }

            if (0 != StartListen(_channel)) {
                WebrtcLog("VoE start listen failed");
                return -1;
            }

            // Route audio to earpiece
            if (0 != SetLoudspeakerStatus(false)) {
                WebrtcLog("VoE set louspeaker status failed");
                return -1;
            }

            /*
             * WebrtcLog("VoE start record now"); if (0 !=
             * StartRecordingPlayout(_channel, "/sdcard/singleUserDemoOut.pcm",
             * false)) { WebrtcLog("VoE Recording Playout failed"); }
             * WebrtcLog("VoE start Recording Playout end");
             */
            // Start playout
            if (0 != StartPlayout(_channel)) {
                WebrtcLog("VoE start playout failed");
                return -1;
            }

            // Start playout file
            // if (0 != StartPlayingFileLocally(_channel,
            // "/sdcard/singleUserDemo.pcm", true)) {
            // WebrtcLog("VoE start playout file failed");
            // return -1;
            // }
        }

        if (enableSend == true) {
            if (0 != SetSendDestination(_channel, _destinationPort,
                            _destinationIP)) {
                WebrtcLog("VoE set send  destination failed");
                return -1;
            }

            if (0 != SetSendCodec(_channel, _codecIndex)) {
                WebrtcLog("VoE set send codec failed");
                return -1;
            }

            /*
             * if (0 != StartPlayingFileAsMicrophone(_channel,
             * "/sdcard/singleUserDemo.pcm", true)) {
             * WebrtcLog("VoE start playing file as microphone failed"); }
             */
            if (0 != StartSend(_channel)) {
                WebrtcLog("VoE start send failed");
                return -1;
            }

            // if (0 != StartPlayingFileAsMicrophone(_channel,
            // "/sdcard/singleUserDemo.pcm", true)) {
            // WebrtcLog("VoE start playing file as microphone failed");
            // return -1;
            // }
        }

        return 0;
    }

    int stopCall() {

        if (useNativeThread == true) {

            Delete();
            return 0;
        }

        if (enableSend == true) {
            // Stop playing file as microphone
            /*
             * if (0 != StopPlayingFileAsMicrophone(_channel)) {
             * WebrtcLog("VoE stop playing file as microphone failed"); return
             * -1; }
             */
            // Stop send
            if (0 != StopSend(_channel)) {
                WebrtcLog("VoE stop send failed");
                return -1;
            }
        }

        if (enableReceive == true) {
            // if (0 != StopRecordingPlayout(_channel)) {
            // WebrtcLog("VoE stop Recording Playout failed");
            // }
            // WebrtcLog("VoE stop Recording Playout ended");

            // Stop listen
            if (0 != StopListen(_channel)) {
                WebrtcLog("VoE stop listen failed");
                return -1;
            }

            // Stop playout file
            // if (0 != StopPlayingFileLocally(_channel)) {
            // WebrtcLog("VoE stop playout file failed");
            // return -1;
            // }

            // Stop playout
            if (0 != StopPlayout(_channel)) {
                WebrtcLog("VoE stop playout failed");
                return -1;
            }

            // Route audio to loudspeaker
            if (0 != SetLoudspeakerStatus(true)) {
                WebrtcLog("VoE set louspeaker status failed");
                return -1;
            }
        }

        return 0;
    }

    int startAutoTest() {

        _autotestThread = new Thread(_autotestProc);
        _autotestThread.start();

        return 0;
    }

    private Runnable _autotestProc = new Runnable() {
        public void run() {
            // TODO(xians): choose test from GUI
            // 1 = standard, not used
            // 2 = extended, 2 = base
            RunAutoTest(1, 2);
        }
    };

    int setAudioProperties(int val) {

        // AudioManager am = (AudioManager)
        // getSystemService(Context.AUDIO_SERVICE);

        if (val == 0) {
            // _streamVolume =
            // am.getStreamVolume(AudioManager.STREAM_VOICE_CALL);
            // am.setStreamVolume(AudioManager.STREAM_VOICE_CALL,
            // (_streamVolume+1), 0);

            int androidVolumeLevel = (_volumeLevel * _maxVolume) / 255;
            if (androidVolumeLevel < _maxVolume) {
                _volumeLevel = ((androidVolumeLevel + 1) * 255) / _maxVolume;
                if (0 != SetSpeakerVolume(_volumeLevel)) {
                    WebrtcLog("VoE set speaker volume failed");
                }
            }
        } else if (val == 1) {
            // _streamVolume =
            // am.getStreamVolume(AudioManager.STREAM_VOICE_CALL);
            // am.setStreamVolume(AudioManager.STREAM_VOICE_CALL,
            // (_streamVolume-1), 0);

            int androidVolumeLevel = (_volumeLevel * _maxVolume) / 255;
            if (androidVolumeLevel > 0) {
                _volumeLevel = ((androidVolumeLevel - 1) * 255) / _maxVolume;
                if (0 != SetSpeakerVolume(_volumeLevel)) {
                    WebrtcLog("VoE set speaker volume failed");
                }
            }
        } else if (val == 2) {
            // route audio to back speaker
            if (0 != SetLoudspeakerStatus(true)) {
                WebrtcLog("VoE set loudspeaker status failed");
            }
            _audioIndex = 2;
        } else if (val == 3) {
            // route audio to earpiece
            if (0 != SetLoudspeakerStatus(false)) {
                WebrtcLog("VoE set loudspeaker status failed");
            }
            _audioIndex = 3;
        }

        return 0;
    }

    int displayTextFromFile() {

        TextView tv = (TextView) findViewById(R.id.TextView01);
        FileReader fr = null;
        char[] fileBuffer = new char[64];

        try {
            fr = new FileReader("/sdcard/test.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            tv.setText("File not found!");
        }

        try {
            fr.read(fileBuffer);
        } catch (IOException e) {
            e.printStackTrace();
        }

        String readString = new String(fileBuffer);
        tv.setText(readString);
        // setContentView(tv);

        return 0;
    }

    int recordAudioToFile() {
        File fr = null;
        // final to be reachable within onPeriodicNotification
        byte[] recBuffer = new byte[320];

        int recBufSize =
                        AudioRecord.getMinBufferSize(16000,
                                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                        AudioFormat.ENCODING_PCM_16BIT);
        AudioRecord rec =
                        new AudioRecord(MediaRecorder.AudioSource.MIC, 16000,
                                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                        AudioFormat.ENCODING_PCM_16BIT,
                                        recBufSize);

        fr = new File("/sdcard/record.pcm");
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(fr);
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        }

        // start recording
        try {
            rec.startRecording();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 550; i++) {
            // note, there is a short version of write as well!
            int wrBytes = rec.read(recBuffer, 0, 320);

            try {
                out.write(recBuffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // stop playout
        try {
            rec.stop();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        }

        return 0;
    }

    int playAudioFromFile() {

        File fr = null;
        // final to be reachable within onPeriodicNotification
        // final byte[] playBuffer = new byte [320000];
        // final to be reachable within onPeriodicNotification
        final byte[] playBuffer = new byte[320];

        final int playBufSize =
                        AudioTrack.getMinBufferSize(16000,
                                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                        AudioFormat.ENCODING_PCM_16BIT);
        // final int playBufSize = 1920; // 100 ms buffer
        // byte[] playBuffer = new byte [playBufSize];
        final AudioTrack play =
                        new AudioTrack(AudioManager.STREAM_VOICE_CALL, 16000,
                                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                        AudioFormat.ENCODING_PCM_16BIT,
                                        playBufSize, AudioTrack.MODE_STREAM);

        // implementation of the playpos callback functions
        play.setPlaybackPositionUpdateListener(
                        new AudioTrack.OnPlaybackPositionUpdateListener() {

            int count = 0;

            public void onPeriodicNotification(AudioTrack track) {
                // int wrBytes = play.write(playBuffer, count, 320);
                count += 320;
            }

            public void onMarkerReached(AudioTrack track) {

            }
        });

        // set the notification period = 160 samples
        // int ret = play.setPositionNotificationPeriod(160);

        fr = new File("/sdcard/record.pcm");
        FileInputStream in = null;
        try {
            in = new FileInputStream(fr);
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        }

        // try {
        // in.read(playBuffer);
        // } catch (IOException e) {
        // e.printStackTrace();
        // }

        // play all at once
        // int wrBytes = play.write(playBuffer, 0, 320000);


        // start playout
        try {
            play.play();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        }

        // returns the number of samples that has been written
        // int headPos = play.getPlaybackHeadPosition();

        // play with multiple writes
        for (int i = 0; i < 500; i++) {
            try {
                in.read(playBuffer);
            } catch (IOException e) {
                e.printStackTrace();
            }


            // note, there is a short version of write as well!
            int wrBytes = play.write(playBuffer, 0, 320);

            Log.d("testWrite", "wrote");
        }

        // stop playout
        try {
            play.stop();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        }

        return 0;
    }

    int playAudioInThread() {

        if (_isRunningPlay) {
            return 0;
        }

        // File fr = null;
        // final byte[] playBuffer = new byte[320];
        if (_playFromFile) {
            _playBuffer = new byte[320];
        } else {
            // reset index
            _playIndex = 0;
        }
        // within
        // onPeriodicNotification

        // Log some info (static)
        WebrtcLog("Creating AudioTrack object");
        final int minPlayBufSize =
                        AudioTrack.getMinBufferSize(16000,
                                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                        AudioFormat.ENCODING_PCM_16BIT);
        WebrtcLog("Min play buf size = " + minPlayBufSize);
        WebrtcLog("Min volume = " + AudioTrack.getMinVolume());
        WebrtcLog("Max volume = " + AudioTrack.getMaxVolume());
        WebrtcLog("Native sample rate = "
                        + AudioTrack.getNativeOutputSampleRate(
                                        AudioManager.STREAM_VOICE_CALL));

        final int playBufSize = minPlayBufSize; // 3200; // 100 ms buffer
        // byte[] playBuffer = new byte [playBufSize];
        try {
            _at = new AudioTrack(
                            AudioManager.STREAM_VOICE_CALL,
                            16000,
                            AudioFormat.CHANNEL_CONFIGURATION_MONO,
                            AudioFormat.ENCODING_PCM_16BIT,
                            playBufSize, AudioTrack.MODE_STREAM);
        } catch (Exception e) {
            WebrtcLog(e.getMessage());
        }

        // Log some info (non-static)
        WebrtcLog("Notification marker pos = "
                        + _at.getNotificationMarkerPosition());
        WebrtcLog("Play head pos = " + _at.getPlaybackHeadPosition());
        WebrtcLog("Pos notification dt = "
                        + _at.getPositionNotificationPeriod());
        WebrtcLog("Playback rate = " + _at.getPlaybackRate());
        WebrtcLog("Sample rate = " + _at.getSampleRate());

        // implementation of the playpos callback functions
        // _at.setPlaybackPositionUpdateListener(
        // new AudioTrack.OnPlaybackPositionUpdateListener() {
        //
        // int count = 3200;
        //
        // public void onPeriodicNotification(AudioTrack track) {
        // // int wrBytes = play.write(playBuffer, count, 320);
        // count += 320;
        // }
        //
        // public void onMarkerReached(AudioTrack track) {
        // }
        // });

        // set the notification period = 160 samples
        // int ret = _at.setPositionNotificationPeriod(160);

        if (_playFromFile) {
            _fr = new File("/sdcard/singleUserDemo.pcm");
            try {
                _in = new FileInputStream(_fr);
            } catch (FileNotFoundException e1) {
                e1.printStackTrace();
            }
        }

        // try {
        // in.read(playBuffer);
        // } catch (IOException e) {
        // e.printStackTrace();
        // }

        _isRunningPlay = true;

        // buffer = new byte[3200];
        _playThread = new Thread(_playProc);
        // ar.startRecording();
        // bytesRead = 3200;
        // recording = true;
        _playThread.start();

        return 0;
    }

    int stopPlayAudio() {
        if (!_isRunningPlay) {
            return 0;
        }

        _isRunningPlay = false;

        return 0;
    }

    private Runnable _playProc = new Runnable() {
        public void run() {

            // set high thread priority
            android.os.Process.setThreadPriority(
                            android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);

            // play all at once
            // int wrBytes = play.write(playBuffer, 0, 320000);

            // fill the buffer
            // play.write(playBuffer, 0, 3200);

            // play.flush();

            // start playout
            try {
                _at.play();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            }

            // play with multiple writes
            int i = 0;
            for (; i < 3000 && _isRunningPlay; i++) {

                if (_playFromFile) {
                    try {
                        _in.read(_playBuffer);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    int wrBytes = _at.write(_playBuffer, 0 /* i * 320 */, 320);
                } else {
                    int wrSamples =
                                    _at.write(_circBuffer, _playIndex * 160,
                                                    160);

                    // WebrtcLog("Played 10 ms from buffer, _playIndex = " +
                    // _playIndex);
                    // WebrtcLog("Diff = " + (_recIndex - _playIndex));

                    if (_playIndex == 49) {
                        _playIndex = 0;
                    } else {
                        _playIndex += 1;
                    }
                }

                // WebrtcLog("Wrote 10 ms to buffer, head = "
                // + _at.getPlaybackHeadPosition());
            }

            // stop playout
            try {
                _at.stop();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            }

            // returns the number of samples that has been written
            WebrtcLog("Test stopped, i = " + i + ", head = "
                            + _at.getPlaybackHeadPosition());
            int headPos = _at.getPlaybackHeadPosition();

            // flush the buffers
            _at.flush();

            // release the object
            _at.release();
            _at = null;

            // try {
            // Thread.sleep() must be within a try - catch block
            // Thread.sleep(3000);
            // }catch (Exception e){
            // System.out.println(e.getMessage());
            // }

            _isRunningPlay = false;

        }
    };

    int recAudioInThread() {

        if (_isRunningRec) {
            return 0;
        }

        // within
        // onPeriodicNotification

        // reset index
        _recIndex = 20;

        // Log some info (static)
        WebrtcLog("Creating AudioRecord object");
        final int minRecBufSize = AudioRecord.getMinBufferSize(16000,
                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                        AudioFormat.ENCODING_PCM_16BIT);
        WebrtcLog("Min rec buf size = " + minRecBufSize);
        // WebrtcLog("Min volume = " + AudioTrack.getMinVolume());
        // WebrtcLog("Max volume = " + AudioTrack.getMaxVolume());
        // WebrtcLog("Native sample rate = "
        // + AudioRecord
        // .getNativeInputSampleRate(AudioManager.STREAM_VOICE_CALL));

        final int recBufSize = minRecBufSize; // 3200; // 100 ms buffer
        try {
            _ar = new AudioRecord(
                            MediaRecorder.AudioSource.MIC,
                            16000,
                            AudioFormat.CHANNEL_CONFIGURATION_MONO,
                            AudioFormat.ENCODING_PCM_16BIT,
                            recBufSize);
        } catch (Exception e) {
            WebrtcLog(e.getMessage());
        }

        // Log some info (non-static)
        WebrtcLog("Notification marker pos = "
                        + _ar.getNotificationMarkerPosition());
        // WebrtcLog("Play head pos = " + _ar.getRecordHeadPosition());
        WebrtcLog("Pos notification dt rec= "
                        + _ar.getPositionNotificationPeriod());
        // WebrtcLog("Playback rate = " + _ar.getRecordRate());
        // WebrtcLog("Playback rate = " + _ar.getPlaybackRate());
        WebrtcLog("Sample rate = " + _ar.getSampleRate());
        // WebrtcLog("Playback rate = " + _ar.getPlaybackRate());
        // WebrtcLog("Playback rate = " + _ar.getPlaybackRate());

        _isRunningRec = true;

        _recThread = new Thread(_recProc);

        _recThread.start();

        return 0;
    }

    int stopRecAudio() {
        if (!_isRunningRec) {
            return 0;
        }

        _isRunningRec = false;

        return 0;
    }

    private Runnable _recProc = new Runnable() {
        public void run() {

            // set high thread priority
            android.os.Process.setThreadPriority(
                            android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);

            // start recording
            try {
                _ar.startRecording();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            }

            // keep recording to circular buffer
            // for a while
            int i = 0;
            int rdSamples = 0;
            short[] tempBuffer = new short[160]; // Only used for native case

            for (; i < 3000 && _isRunningRec; i++) {
                if (_runThroughNativeLayer) {
                    rdSamples = _ar.read(tempBuffer, 0, 160);
                    // audioLoop(tempBuffer, 160); // Insert into native layer
                } else {
                    rdSamples = _ar.read(_circBuffer, _recIndex * 160, 160);

                    // WebrtcLog("Recorded 10 ms to buffer, _recIndex = " +
                    // _recIndex);
                    // WebrtcLog("rdSamples = " + rdSamples);

                    if (_recIndex == 49) {
                        _recIndex = 0;
                    } else {
                        _recIndex += 1;
                    }
                }
            }

            // stop recording
            try {
                _ar.stop();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            }

            // release the object
            _ar.release();
            _ar = null;

            // try {
            // Thread.sleep() must be within a try - catch block
            // Thread.sleep(3000);
            // }catch (Exception e){
            // System.out.println(e.getMessage());
            // }

            _isRunningRec = false;

            // returns the number of samples that has been written
            // WebrtcLog("Test stopped, i = " + i + ", head = "
            // + _at.getPlaybackHeadPosition());
            // int headPos = _at.getPlaybackHeadPosition();
        }
    };

    private void WebrtcLog(String msg) {
        Log.d("*Webrtc*", msg);
    }

    // //////////////// Native function prototypes ////////////////////

    private native static boolean NativeInit();

    private native int RunAutoTest(int testType, int extendedSel);

    private native boolean Create();

    private native boolean Delete();

    private native int Init(boolean enableTrace, boolean useExtTrans);

    private native int Terminate();

    private native int CreateChannel();

    private native int DeleteChannel(int channel);

    private native int SetLocalReceiver(int channel, int port);

    private native int SetSendDestination(int channel, int port,
                    String ipaddr);

    private native int StartListen(int channel);

    private native int StartPlayout(int channel);

    private native int StartSend(int channel);

    private native int StopListen(int channel);

    private native int StopPlayout(int channel);

    private native int StopSend(int channel);

    private native int StartPlayingFileLocally(int channel, String fileName,
                    boolean loop);

    private native int StopPlayingFileLocally(int channel);

    private native int StartRecordingPlayout(int channel, String fileName,
                    boolean loop);

    private native int StopRecordingPlayout(int channel);

    private native int StartPlayingFileAsMicrophone(int channel,
                    String fileName, boolean loop);

    private native int StopPlayingFileAsMicrophone(int channel);

    private native int NumOfCodecs();

    private native int SetSendCodec(int channel, int index);

    private native int SetVADStatus(int channel, boolean enable, int mode);

    private native int SetNSStatus(boolean enable, int mode);

    private native int SetAGCStatus(boolean enable, int mode);

    private native int SetECStatus(boolean enable, int mode);

    private native int SetSpeakerVolume(int volume);

    private native int SetLoudspeakerStatus(boolean enable);

    /*
     * this is used to load the 'webrtc-voice-demo-jni'
     * library on application startup.
     * The library has already been unpacked into
     * /data/data/webrtc.android.AndroidTest/lib/libwebrtc-voice-demo-jni.so
     * at installation time by the package manager.
     */
    static {
        Log.d("*Webrtc*", "Loading webrtc-voice-demo-jni...");
        System.loadLibrary("webrtc-voice-demo-jni");

        Log.d("*Webrtc*", "Calling native init...");
        if (!NativeInit()) {
            Log.e("*Webrtc*", "Native init failed");
            throw new RuntimeException("Native init failed");
        } else {
            Log.d("*Webrtc*", "Native init successful");
        }
    }
}