audio_device/android/audio_record_jni.cc

/*
 *  Copyright (c) 2013 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.
 */

/*
 *  Android audio device implementation (JNI/AudioRecord usage)
 */

// TODO(xians): Break out attach and detach current thread to JVM to
// separate functions.

#include "webrtc/modules/audio_device/android/audio_record_jni.h"

#include <android/log.h>
#include <stdlib.h>

#include "webrtc/modules/audio_device/android/audio_common.h"
#include "webrtc/modules/audio_device/audio_device_config.h"
#include "webrtc/modules/audio_device/audio_device_utility.h"

#include "webrtc/system_wrappers/interface/event_wrapper.h"
#include "webrtc/system_wrappers/interface/thread_wrapper.h"
#include "webrtc/system_wrappers/interface/trace.h"

namespace webrtc {

JavaVM* AudioRecordJni::globalJvm = NULL;
JNIEnv* AudioRecordJni::globalJNIEnv = NULL;
jobject AudioRecordJni::globalContext = NULL;
jclass AudioRecordJni::globalScClass = NULL;

int32_t AudioRecordJni::SetAndroidAudioDeviceObjects(void* javaVM, void* env,
                                                     void* context) {
  assert(env);
  globalJvm = reinterpret_cast<JavaVM*>(javaVM);
  globalJNIEnv = reinterpret_cast<JNIEnv*>(env);
  // Get java class type (note path to class packet).
  jclass javaScClassLocal = globalJNIEnv->FindClass(
      "org/webrtc/voiceengine/WebRtcAudioRecord");
  if (!javaScClassLocal) {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1,
                 "%s: could not find java class", __FUNCTION__);
    return -1; // exception thrown
  }

  // Create a global reference to the class (to tell JNI that we are
  // referencing it after this function has returned).
  globalScClass = reinterpret_cast<jclass> (
      globalJNIEnv->NewGlobalRef(javaScClassLocal));
  if (!globalScClass) {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1,
                 "%s: could not create reference", __FUNCTION__);
    return -1;
  }

  globalContext = globalJNIEnv->NewGlobalRef(
      reinterpret_cast<jobject>(context));
  if (!globalContext) {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1,
                 "%s: could not create context reference", __FUNCTION__);
    return -1;
  }

  // Delete local class ref, we only use the global ref
  globalJNIEnv->DeleteLocalRef(javaScClassLocal);

  return 0;
}

void AudioRecordJni::ClearAndroidAudioDeviceObjects() {
  WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, -1,
               "%s: env is NULL, assuming deinit", __FUNCTION__);

  globalJvm = NULL;;
  if (!globalJNIEnv) {
    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, -1,
                 "%s: saved env already NULL", __FUNCTION__);
    return;
  }

  globalJNIEnv->DeleteGlobalRef(globalContext);
  globalContext = reinterpret_cast<jobject>(NULL);

  globalJNIEnv->DeleteGlobalRef(globalScClass);
  globalScClass = reinterpret_cast<jclass>(NULL);

  globalJNIEnv = reinterpret_cast<JNIEnv*>(NULL);
}

AudioRecordJni::AudioRecordJni(
    const int32_t id, PlayoutDelayProvider* delay_provider)
    : _javaVM(NULL),
      _jniEnvRec(NULL),
      _javaScClass(0),
      _javaScObj(0),
      _javaRecBuffer(0),
      _javaDirectRecBuffer(NULL),
      _javaMidRecAudio(0),
      _ptrAudioBuffer(NULL),
      _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
      _id(id),
      _delay_provider(delay_provider),
      _initialized(false),
      _timeEventRec(*EventWrapper::Create()),
      _recStartStopEvent(*EventWrapper::Create()),
      _ptrThreadRec(NULL),
      _recThreadID(0),
      _recThreadIsInitialized(false),
      _shutdownRecThread(false),
      _recordingDeviceIsSpecified(false),
      _recording(false),
      _recIsInitialized(false),
      _micIsInitialized(false),
      _startRec(false),
      _recWarning(0),
      _recError(0),
      _delayRecording(0),
      _AGC(false),
      _samplingFreqIn((N_REC_SAMPLES_PER_SEC/1000)),
      _recAudioSource(1) { // 1 is AudioSource.MIC which is our default
  memset(_recBuffer, 0, sizeof(_recBuffer));
}

AudioRecordJni::~AudioRecordJni() {
  WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
               "%s destroyed", __FUNCTION__);

  Terminate();

  delete &_recStartStopEvent;
  delete &_timeEventRec;
  delete &_critSect;
}

int32_t AudioRecordJni::Init() {
  CriticalSectionScoped lock(&_critSect);

  if (_initialized)
  {
    return 0;
  }

  _recWarning = 0;
  _recError = 0;

  // Init Java member variables
  // and set up JNI interface to
  // AudioDeviceAndroid java class
  if (InitJavaResources() != 0)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: Failed to init Java resources", __FUNCTION__);
    return -1;
  }

  // Check the sample rate to be used for playback and recording
  // and the max playout volume
  if (InitSampleRate() != 0)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: Failed to init samplerate", __FUNCTION__);
    return -1;
  }

  const char* threadName = "jni_audio_capture_thread";
  _ptrThreadRec = ThreadWrapper::CreateThread(RecThreadFunc, this,
                                              kRealtimePriority, threadName);
  if (_ptrThreadRec == NULL)
  {
    WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
                 "  failed to create the rec audio thread");
    return -1;
  }

  unsigned int threadID(0);
  if (!_ptrThreadRec->Start(threadID))
  {
    WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
                 "  failed to start the rec audio thread");
    delete _ptrThreadRec;
    _ptrThreadRec = NULL;
    return -1;
  }
  _recThreadID = threadID;
  _initialized = true;

  return 0;
}

int32_t AudioRecordJni::Terminate() {
  CriticalSectionScoped lock(&_critSect);

  if (!_initialized)
  {
    return 0;
  }

  StopRecording();
  _shutdownRecThread = true;
  _timeEventRec.Set(); // Release rec thread from waiting state
  if (_ptrThreadRec)
  {
    // First, the thread must detach itself from Java VM
    _critSect.Leave();
    if (kEventSignaled != _recStartStopEvent.Wait(5000))
    {
      WEBRTC_TRACE(
          kTraceError,
          kTraceAudioDevice,
          _id,
          "%s: Recording thread shutdown timed out, cannot "
          "terminate thread",
          __FUNCTION__);
      // If we close thread anyway, the app will crash
      return -1;
    }
    _recStartStopEvent.Reset();
    _critSect.Enter();

    // Close down rec thread
    ThreadWrapper* tmpThread = _ptrThreadRec;
    _ptrThreadRec = NULL;
    _critSect.Leave();
    tmpThread->SetNotAlive();
    // Release again, we might have returned to waiting state
    _timeEventRec.Set();
    if (tmpThread->Stop())
    {
      delete tmpThread;
      _jniEnvRec = NULL;
    }
    else
    {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                   "  failed to close down the rec audio thread");
    }
    _critSect.Enter();

    _recThreadIsInitialized = false;
  }
  _micIsInitialized = false;
  _recordingDeviceIsSpecified = false;

  // get the JNI env for this thread
  JNIEnv *env;
  bool isAttached = false;

  // get the JNI env for this thread
  if (_javaVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
  {
    // try to attach the thread and get the env
    // Attach this thread to JVM
    jint res = _javaVM->AttachCurrentThread(&env, NULL);
    if ((res < 0) || !env)
    {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "%s: Could not attach thread to JVM (%d, %p)",
                   __FUNCTION__, res, env);
      return -1;
    }
    isAttached = true;
  }

  // Make method IDs and buffer pointers unusable
  _javaMidRecAudio = 0;
  _javaDirectRecBuffer = NULL;

  // Delete the references to the java buffers, this allows the
  // garbage collector to delete them
  env->DeleteGlobalRef(_javaRecBuffer);
  _javaRecBuffer = 0;

  // Delete the references to the java object and class, this allows the
  // garbage collector to delete them
  env->DeleteGlobalRef(_javaScObj);
  _javaScObj = 0;
  _javaScClass = 0;

  // Detach this thread if it was attached
  if (isAttached)
  {
    if (_javaVM->DetachCurrentThread() < 0)
    {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                   "%s: Could not detach thread from JVM", __FUNCTION__);
    }
  }

  _initialized = false;

  return 0;
}

int32_t AudioRecordJni::RecordingDeviceName(uint16_t index,
                                            char name[kAdmMaxDeviceNameSize],
                                            char guid[kAdmMaxGuidSize]) {
  if (0 != index)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Device index is out of range [0,0]");
    return -1;
  }

  // Return empty string
  memset(name, 0, kAdmMaxDeviceNameSize);

  if (guid)
  {
    memset(guid, 0, kAdmMaxGuidSize);
  }

  return 0;
}

int32_t AudioRecordJni::SetRecordingDevice(uint16_t index) {
  if (_recIsInitialized)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Recording already initialized");
    return -1;
  }

  // Recording device index will be used for specifying recording
  // audio source, allow any value
  _recAudioSource = index;
  _recordingDeviceIsSpecified = true;

  return 0;
}

int32_t AudioRecordJni::SetRecordingDevice(
    AudioDeviceModule::WindowsDeviceType device) {
  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::RecordingIsAvailable(bool& available) {  // NOLINT
  available = false;

  // Try to initialize the playout side
  int32_t res = InitRecording();

  // Cancel effect of initialization
  StopRecording();

  if (res != -1)
  {
    available = true;
  }

  return res;
}

int32_t AudioRecordJni::InitRecording() {
  CriticalSectionScoped lock(&_critSect);

  if (!_initialized)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Not initialized");
    return -1;
  }

  if (_recording)
  {
    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "  Recording already started");
    return -1;
  }

  if (!_recordingDeviceIsSpecified)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Recording device is not specified");
    return -1;
  }

  if (_recIsInitialized)
  {
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "  Recording already initialized");
    return 0;
  }

  // Initialize the microphone
  if (InitMicrophone() == -1)
  {
    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "  InitMicrophone() failed");
  }

  // get the JNI env for this thread
  JNIEnv *env;
  bool isAttached = false;

  // get the JNI env for this thread
  if (_javaVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
  {
    // try to attach the thread and get the env
    // Attach this thread to JVM
    jint res = _javaVM->AttachCurrentThread(&env, NULL);
    if ((res < 0) || !env)
    {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "  Could not attach thread to JVM (%d, %p)", res, env);
      return -1;
    }
    isAttached = true;
  }

  // get the method ID
  jmethodID initRecordingID = env->GetMethodID(_javaScClass, "InitRecording",
                                               "(II)I");

  int samplingFreq = 44100;
  if (_samplingFreqIn != 44)
  {
    samplingFreq = _samplingFreqIn * 1000;
  }

  int retVal = -1;

  // call java sc object method
  jint res = env->CallIntMethod(_javaScObj, initRecordingID, _recAudioSource,
                                samplingFreq);
  if (res < 0)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "InitRecording failed (%d)", res);
  }
  else
  {
    // Set the audio device buffer sampling rate
    _ptrAudioBuffer->SetRecordingSampleRate(_samplingFreqIn * 1000);

    // the init rec function returns a fixed delay
    _delayRecording = res / _samplingFreqIn;

    _recIsInitialized = true;
    retVal = 0;
  }

  // Detach this thread if it was attached
  if (isAttached)
  {
    if (_javaVM->DetachCurrentThread() < 0)
    {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                   "  Could not detach thread from JVM");
    }
  }

  return retVal;
}

int32_t AudioRecordJni::StartRecording() {
  CriticalSectionScoped lock(&_critSect);

  if (!_recIsInitialized)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Recording not initialized");
    return -1;
  }

  if (_recording)
  {
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "  Recording already started");
    return 0;
  }

  // get the JNI env for this thread
  JNIEnv *env;
  bool isAttached = false;

  // get the JNI env for this thread
  if (_javaVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
  {
    // try to attach the thread and get the env
    // Attach this thread to JVM
    jint res = _javaVM->AttachCurrentThread(&env, NULL);
    if ((res < 0) || !env)
    {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "  Could not attach thread to JVM (%d, %p)", res, env);
      return -1;
    }
    isAttached = true;
  }

  // get the method ID
  jmethodID startRecordingID = env->GetMethodID(_javaScClass,
                                                "StartRecording", "()I");

  // Call java sc object method
  jint res = env->CallIntMethod(_javaScObj, startRecordingID);
  if (res < 0)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "StartRecording failed (%d)", res);
    return -1;
  }

  _recWarning = 0;
  _recError = 0;

  // Signal to recording thread that we want to start
  _startRec = true;
  _timeEventRec.Set(); // Release thread from waiting state
  _critSect.Leave();
  // Wait for thread to init
  if (kEventSignaled != _recStartStopEvent.Wait(5000))
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Timeout or error starting");
  }
  _recStartStopEvent.Reset();
  _critSect.Enter();

  // Detach this thread if it was attached
  if (isAttached)
  {
    if (_javaVM->DetachCurrentThread() < 0)
    {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                   "  Could not detach thread from JVM");
    }
  }

  return 0;

}

int32_t AudioRecordJni::StopRecording() {
  CriticalSectionScoped lock(&_critSect);

  if (!_recIsInitialized)
  {
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "  Recording is not initialized");
    return 0;
  }

  // make sure we don't start recording (it's asynchronous),
  // assuming that we are under lock
  _startRec = false;

  // get the JNI env for this thread
  JNIEnv *env;
  bool isAttached = false;

  // get the JNI env for this thread
  if (_javaVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
  {
    // try to attach the thread and get the env
    // Attach this thread to JVM
    jint res = _javaVM->AttachCurrentThread(&env, NULL);
    if ((res < 0) || !env)
    {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "  Could not attach thread to JVM (%d, %p)", res, env);
      return -1;
    }
    isAttached = true;
  }

  // get the method ID
  jmethodID stopRecordingID = env->GetMethodID(_javaScClass, "StopRecording",
                                               "()I");

  // Call java sc object method
  jint res = env->CallIntMethod(_javaScObj, stopRecordingID);
  if (res < 0)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "StopRecording failed (%d)", res);
  }

  _recIsInitialized = false;
  _recording = false;
  _recWarning = 0;
  _recError = 0;

  // Detach this thread if it was attached
  if (isAttached)
  {
    if (_javaVM->DetachCurrentThread() < 0)
    {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                   "  Could not detach thread from JVM");
    }
  }

  return 0;

}

int32_t AudioRecordJni::SetAGC(bool enable) {
  _AGC = enable;
  return 0;
}

int32_t AudioRecordJni::InitMicrophone() {
  CriticalSectionScoped lock(&_critSect);

  if (_recording)
  {
    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "  Recording already started");
    return -1;
  }

  if (!_recordingDeviceIsSpecified)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Recording device is not specified");
    return -1;
  }

  // Nothing needs to be done here, we use a flag to have consistent
  // behavior with other platforms
  _micIsInitialized = true;

  return 0;
}

int32_t AudioRecordJni::MicrophoneVolumeIsAvailable(
    bool& available) {  // NOLINT
  available = false;  // Mic volume not supported on Android
  return 0;
}

int32_t AudioRecordJni::SetMicrophoneVolume( uint32_t /*volume*/) {

  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::MicrophoneVolume(uint32_t& volume) const {  // NOLINT
  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::MaxMicrophoneVolume(
    uint32_t& maxVolume) const {  // NOLINT
  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::MinMicrophoneVolume(
    uint32_t& minVolume) const {  // NOLINT
  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::MicrophoneVolumeStepSize(
    uint16_t& stepSize) const {
  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::MicrophoneMuteIsAvailable(bool& available) {  // NOLINT
  available = false; // Mic mute not supported on Android
  return 0;
}

int32_t AudioRecordJni::SetMicrophoneMute(bool enable) {
  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::MicrophoneMute(bool& enabled) const {  // NOLINT
  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
               "  API call not supported on this platform");
  return -1;
}

int32_t AudioRecordJni::MicrophoneBoostIsAvailable(bool& available) {  // NOLINT
  available = false; // Mic boost not supported on Android
  return 0;
}

int32_t AudioRecordJni::SetMicrophoneBoost(bool enable) {
  if (!_micIsInitialized)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Microphone not initialized");
    return -1;
  }

  if (enable)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Enabling not available");
    return -1;
  }

  return 0;
}

int32_t AudioRecordJni::MicrophoneBoost(bool& enabled) const {  // NOLINT
  if (!_micIsInitialized)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Microphone not initialized");
    return -1;
  }

  enabled = false;

  return 0;
}

int32_t AudioRecordJni::StereoRecordingIsAvailable(bool& available) {  // NOLINT
  available = false; // Stereo recording not supported on Android
  return 0;
}

int32_t AudioRecordJni::SetStereoRecording(bool enable) {
  if (enable)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Enabling not available");
    return -1;
  }

  return 0;
}

int32_t AudioRecordJni::StereoRecording(bool& enabled) const {  // NOLINT
  enabled = false;
  return 0;
}

int32_t AudioRecordJni::RecordingDelay(uint16_t& delayMS) const {  // NOLINT
  delayMS = _delayRecording;
  return 0;
}

bool AudioRecordJni::RecordingWarning() const {
  return (_recWarning > 0);
}

bool AudioRecordJni::RecordingError() const {
  return (_recError > 0);
}

void AudioRecordJni::ClearRecordingWarning() {
  _recWarning = 0;
}

void AudioRecordJni::ClearRecordingError() {
  _recError = 0;
}

void AudioRecordJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
  CriticalSectionScoped lock(&_critSect);
  _ptrAudioBuffer = audioBuffer;
  // inform the AudioBuffer about default settings for this implementation
  _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
  _ptrAudioBuffer->SetRecordingChannels(N_REC_CHANNELS);
}

int32_t AudioRecordJni::SetRecordingSampleRate(const uint32_t samplesPerSec) {
  if (samplesPerSec > 48000 || samplesPerSec < 8000)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "  Invalid sample rate");
    return -1;
  }

  // set the recording sample rate to use
  if (samplesPerSec == 44100)
  {
    _samplingFreqIn = 44;
  }
  else
  {
    _samplingFreqIn = samplesPerSec / 1000;
  }

  // Update the AudioDeviceBuffer
  _ptrAudioBuffer->SetRecordingSampleRate(samplesPerSec);

  return 0;
}

int32_t AudioRecordJni::InitJavaResources() {
  // todo: Check if we already have created the java object
  _javaVM = globalJvm;
  _javaScClass = globalScClass;

  // use the jvm that has been set
  if (!_javaVM)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: Not a valid Java VM pointer", __FUNCTION__);
    return -1;
  }

  // get the JNI env for this thread
  JNIEnv *env;
  bool isAttached = false;

  // get the JNI env for this thread
  if (_javaVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
  {
    // try to attach the thread and get the env
    // Attach this thread to JVM
    jint res = _javaVM->AttachCurrentThread(&env, NULL);
    if ((res < 0) || !env)
    {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "%s: Could not attach thread to JVM (%d, %p)",
                   __FUNCTION__, res, env);
      return -1;
    }
    isAttached = true;
  }

  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
               "get method id");

  // get the method ID for the void(void) constructor
  jmethodID cid = env->GetMethodID(_javaScClass, "<init>", "()V");
  if (cid == NULL)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: could not get constructor ID", __FUNCTION__);
    return -1; /* exception thrown */
  }

  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
               "construct object", __FUNCTION__);

  // construct the object
  jobject javaScObjLocal = env->NewObject(_javaScClass, cid);
  if (!javaScObjLocal)
  {
    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "%s: could not create Java sc object", __FUNCTION__);
    return -1;
  }

  // Create a reference to the object (to tell JNI that we are referencing it
  // after this function has returned).
  _javaScObj = env->NewGlobalRef(javaScObjLocal);
  if (!_javaScObj)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: could not create Java sc object reference",
                 __FUNCTION__);
    return -1;
  }

  // Delete local object ref, we only use the global ref.
  env->DeleteLocalRef(javaScObjLocal);

  //////////////////////
  // AUDIO MANAGEMENT

  // This is not mandatory functionality
  if (globalContext) {
    jfieldID context_id = env->GetFieldID(globalScClass,
                                          "_context",
                                          "Landroid/content/Context;");
    if (!context_id) {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "%s: could not get _context id", __FUNCTION__);
      return -1;
    }

    env->SetObjectField(_javaScObj, context_id, globalContext);
    jobject javaContext = env->GetObjectField(_javaScObj, context_id);
    if (!javaContext) {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "%s: could not set or get _context", __FUNCTION__);
      return -1;
    }
  }
  else {
    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "%s: did not set Context - some functionality is not "
                 "supported",
                 __FUNCTION__);
  }

  // Get rec buffer field ID.
  jfieldID fidRecBuffer = env->GetFieldID(_javaScClass, "_recBuffer",
                                          "Ljava/nio/ByteBuffer;");
  if (!fidRecBuffer)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: could not get rec buffer fid", __FUNCTION__);
    return -1;
  }

  // Get rec buffer object.
  jobject javaRecBufferLocal = env->GetObjectField(_javaScObj, fidRecBuffer);
  if (!javaRecBufferLocal)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: could not get rec buffer", __FUNCTION__);
    return -1;
  }

  // Create a global reference to the object (to tell JNI that we are
  // referencing it after this function has returned)
  // NOTE: we are referencing it only through the direct buffer (see below).
  _javaRecBuffer = env->NewGlobalRef(javaRecBufferLocal);
  if (!_javaRecBuffer)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: could not get rec buffer reference", __FUNCTION__);
    return -1;
  }

  // Delete local object ref, we only use the global ref.
  env->DeleteLocalRef(javaRecBufferLocal);

  // Get direct buffer.
  _javaDirectRecBuffer = env->GetDirectBufferAddress(_javaRecBuffer);
  if (!_javaDirectRecBuffer)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: could not get direct rec buffer", __FUNCTION__);
    return -1;
  }

  // Get the rec audio method ID.
  _javaMidRecAudio = env->GetMethodID(_javaScClass, "RecordAudio", "(I)I");
  if (!_javaMidRecAudio)
  {
    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                 "%s: could not get rec audio mid", __FUNCTION__);
    return -1;
  }

  // Detach this thread if it was attached.
  if (isAttached)
  {
    if (_javaVM->DetachCurrentThread() < 0)
    {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                   "%s: Could not detach thread from JVM", __FUNCTION__);
    }
  }

  return 0;

}

int32_t AudioRecordJni::InitSampleRate() {
  int samplingFreq = 44100;
  jint res = 0;

  // get the JNI env for this thread
  JNIEnv *env;
  bool isAttached = false;

  // get the JNI env for this thread
  if (_javaVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
  {
    // try to attach the thread and get the env
    // Attach this thread to JVM
    jint res = _javaVM->AttachCurrentThread(&env, NULL);
    if ((res < 0) || !env)
    {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "%s: Could not attach thread to JVM (%d, %p)",
                   __FUNCTION__, res, env);
      return -1;
    }
    isAttached = true;
  }

  if (_samplingFreqIn > 0)
  {
    // read the configured sampling rate
    samplingFreq = 44100;
    if (_samplingFreqIn != 44)
    {
      samplingFreq = _samplingFreqIn * 1000;
    }
    WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
                 "  Trying configured recording sampling rate %d",
                 samplingFreq);
  }

  // get the method ID
  jmethodID initRecordingID = env->GetMethodID(_javaScClass, "InitRecording",
                                               "(II)I");

  bool keepTrying = true;
  while (keepTrying)
  {
    // call java sc object method
    res = env->CallIntMethod(_javaScObj, initRecordingID, _recAudioSource,
                             samplingFreq);
    if (res < 0)
    {
      switch (samplingFreq)
      {
        case 44100:
          samplingFreq = 16000;
          break;
        case 16000:
          samplingFreq = 8000;
          break;
        default: // error
          WEBRTC_TRACE(kTraceError,
                       kTraceAudioDevice, _id,
                       "%s: InitRecording failed (%d)", __FUNCTION__,
                       res);
          return -1;
      }
    }
    else
    {
      keepTrying = false;
    }
  }

  // set the recording sample rate to use
  if (samplingFreq == 44100)
  {
    _samplingFreqIn = 44;
  }
  else
  {
    _samplingFreqIn = samplingFreq / 1000;
  }

  WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
               "Recording sample rate set to (%d)", _samplingFreqIn);

  // get the method ID
  jmethodID stopRecordingID = env->GetMethodID(_javaScClass, "StopRecording",
                                               "()I");

  // Call java sc object method
  res = env->CallIntMethod(_javaScObj, stopRecordingID);
  if (res < 0)
  {
    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "StopRecording failed (%d)", res);
  }

  // Detach this thread if it was attached
  if (isAttached)
  {
    if (_javaVM->DetachCurrentThread() < 0)
    {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                   "%s: Could not detach thread from JVM", __FUNCTION__);
    }
  }

  return 0;
}

bool AudioRecordJni::RecThreadFunc(void* pThis)
{
  return (static_cast<AudioRecordJni*> (pThis)->RecThreadProcess());
}

bool AudioRecordJni::RecThreadProcess()
{
  if (!_recThreadIsInitialized)
  {
    // Do once when thread is started

    // Attach this thread to JVM
    jint res = _javaVM->AttachCurrentThread(&_jniEnvRec, NULL);

    // Get the JNI env for this thread
    if ((res < 0) || !_jniEnvRec)
    {
      WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice,
                   _id, "Could not attach rec thread to JVM (%d, %p)",
                   res, _jniEnvRec);
      return false; // Close down thread
    }

    _recThreadIsInitialized = true;
  }

  // just sleep if rec has not started
  if (!_recording)
  {
    switch (_timeEventRec.Wait(1000))
    {
      case kEventSignaled:
        WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice,
                     _id, "Recording thread event signal");
        _timeEventRec.Reset();
        break;
      case kEventError:
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice,
                     _id, "Recording thread event error");
        return true;
      case kEventTimeout:
        WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice,
                     _id, "Recording thread event timeout");
        return true;
    }
  }

  Lock();

  if (_startRec)
  {
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "_startRec true, performing initial actions");
    _startRec = false;
    _recording = true;
    _recWarning = 0;
    _recError = 0;
    _recStartStopEvent.Set();
  }

  if (_recording)
  {
    uint32_t samplesToRec = _samplingFreqIn * 10;

    // Call java sc object method to record data to direct buffer
    // Will block until data has been recorded (see java sc class),
    // therefore we must release the lock
    UnLock();
    jint recDelayInSamples = _jniEnvRec->CallIntMethod(_javaScObj,
                                                        _javaMidRecAudio,
                                                        2 * samplesToRec);
    if (recDelayInSamples < 0)
    {
      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                   "RecordAudio failed");
      _recWarning = 1;
    }
    else
    {
      _delayRecording = recDelayInSamples / _samplingFreqIn;
    }
    Lock();

    // Check again since recording may have stopped during Java call
    if (_recording)
    {
      //            WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
      //                         "total delay is %d", msPlayDelay + _delayRecording);

      // Copy data to our direct buffer (held by java sc object)
      // todo: Give _javaDirectRecBuffer directly to VoE?
      // todo: Check count <= 480 ?
      memcpy(_recBuffer, _javaDirectRecBuffer, 2 * samplesToRec);

      // store the recorded buffer (no action will be taken if the
      // #recorded samples is not a full buffer)
      _ptrAudioBuffer->SetRecordedBuffer(_recBuffer, samplesToRec);

      // store vqe delay values
      _ptrAudioBuffer->SetVQEData(_delay_provider->PlayoutDelayMs(),
                                  _delayRecording, 0);

      // deliver recorded samples at specified sample rate, mic level
      // etc. to the observer using callback
      UnLock();
      _ptrAudioBuffer->DeliverRecordedData();
      Lock();
    }

  }  // _recording

  if (_shutdownRecThread)
  {
    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
                 "Detaching rec thread from Java VM");

    // Detach thread from Java VM
    if (_javaVM->DetachCurrentThread() < 0)
    {
      WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice,
                   _id, "Could not detach recording thread from JVM");
      _shutdownRecThread = false;
      // If we say OK (i.e. set event) and close thread anyway,
      // app will crash
    }
    else
    {
      _jniEnvRec = NULL;
      _shutdownRecThread = false;
      _recStartStopEvent.Set(); // Signal to Terminate() that we are done

      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
                   "Sent signal rec");
    }
  }

  UnLock();
  return true;
}

}  // namespace webrtc