Adds support for OpenSL ES based audio capture on Android

webrtc/modules/audio_device/android/audio_device_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
@@ skipping 24 matching lines @@
 
 using std::cout;
 using std::endl;
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::Gt;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
-using ::testing::TestWithParam;
 
 // #define ENABLE_DEBUG_PRINTF
 #ifdef ENABLE_DEBUG_PRINTF
 #define PRINTD(...) fprintf(stderr, __VA_ARGS__);
 #else
 #define PRINTD(...) ((void)0)
 #endif
 #define PRINT(...) fprintf(stderr, __VA_ARGS__);
 
 namespace webrtc {
@@ skipping 656 matching lines @@
   AudioParameters record_parameters_;
   std::unique_ptr<BuildInfo> build_info_;
 };
 
 TEST_F(AudioDeviceTest, ConstructDestruct) {
   // Using the test fixture to create and destruct the audio device module.
 }
 
 // We always ask for a default audio layer when the ADM is constructed. But the
 // ADM will then internally set the best suitable combination of audio layers,
-// for input and output based on if low-latency output audio in combination
-// with OpenSL ES is supported or not. This test ensures that the correct
-// selection is done.
+// for input and output based on if low-latency output and/or input audio in
+// combination with OpenSL ES is supported or not. This test ensures that the
+// correct selection is done.
 TEST_F(AudioDeviceTest, VerifyDefaultAudioLayer) {
   const AudioDeviceModule::AudioLayer audio_layer = GetActiveAudioLayer();
   bool low_latency_output = audio_manager()->IsLowLatencyPlayoutSupported();
-  AudioDeviceModule::AudioLayer expected_audio_layer = low_latency_output ?
-      AudioDeviceModule::kAndroidJavaInputAndOpenSLESOutputAudio :
-      AudioDeviceModule::kAndroidJavaAudio;
+  bool low_latency_input = audio_manager()->IsLowLatencyRecordSupported();
+  AudioDeviceModule::AudioLayer expected_audio_layer;
+  if (low_latency_output && low_latency_input) {
+    expected_audio_layer = AudioDeviceModule::kAndroidOpenSLESAudio;
+  } else if (low_latency_output && !low_latency_input) {
+    expected_audio_layer =
+        AudioDeviceModule::kAndroidJavaInputAndOpenSLESOutputAudio;
+  } else {
+    expected_audio_layer = AudioDeviceModule::kAndroidJavaAudio;
+  }
   EXPECT_EQ(expected_audio_layer, audio_layer);
 }
 
 // Verify that it is possible to explicitly create the two types of supported
 // ADMs. These two tests overrides the default selection of native audio layer
 // by ignoring if the device supports low-latency output or not.
 TEST_F(AudioDeviceTest, CorrectAudioLayerIsUsedForCombinedJavaOpenSLCombo) {
   AudioDeviceModule::AudioLayer expected_layer =
       AudioDeviceModule::kAndroidJavaInputAndOpenSLESOutputAudio;
   AudioDeviceModule::AudioLayer active_layer = TestActiveAudioLayer(
       expected_layer);
   EXPECT_EQ(expected_layer, active_layer);
 }
 
 TEST_F(AudioDeviceTest, CorrectAudioLayerIsUsedForJavaInBothDirections) {
   AudioDeviceModule::AudioLayer expected_layer =
       AudioDeviceModule::kAndroidJavaAudio;
   AudioDeviceModule::AudioLayer active_layer = TestActiveAudioLayer(
       expected_layer);
   EXPECT_EQ(expected_layer, active_layer);
 }
 
+TEST_F(AudioDeviceTest, CorrectAudioLayerIsUsedForOpenSLInBothDirections) {
+  AudioDeviceModule::AudioLayer expected_layer =
+      AudioDeviceModule::kAndroidOpenSLESAudio;
+  AudioDeviceModule::AudioLayer active_layer =
+      TestActiveAudioLayer(expected_layer);
+  EXPECT_EQ(expected_layer, active_layer);
+}
+
 // The Android ADM supports two different delay reporting modes. One for the
 // low-latency output path (in combination with OpenSL ES), and one for the
 // high-latency output path (Java backends in both directions). These two tests
 // verifies that the audio manager reports correct delay estimate given the
 // selected audio layer. Note that, this delay estimate will only be utilized
 // if the HW AEC is disabled.
 TEST_F(AudioDeviceTest, UsesCorrectDelayEstimateForHighLatencyOutputPath) {
   EXPECT_EQ(kHighLatencyModeDelayEstimateInMilliseconds,
             TestDelayOnAudioLayer(AudioDeviceModule::kAndroidJavaAudio));
 }
@@ skipping 93 matching lines @@
 TEST_F(AudioDeviceTest, StartStopRecording) {
   StartRecording();
   StopRecording();
   StartRecording();
   StopRecording();
 }
 
 // Verify that calling StopPlayout() will leave us in an uninitialized state
 // which will require a new call to InitPlayout(). This test does not call
 // StartPlayout() while being uninitialized since doing so will hit a
-// RTC_DCHECK.
+// RTC_DCHECK and death tests are not supported on Android.
 TEST_F(AudioDeviceTest, StopPlayoutRequiresInitToRestart) {
   EXPECT_EQ(0, audio_device()->InitPlayout());
   EXPECT_EQ(0, audio_device()->StartPlayout());
   EXPECT_EQ(0, audio_device()->StopPlayout());
   EXPECT_FALSE(audio_device()->PlayoutIsInitialized());
 }
 
+// Verify that calling StopRecording() will leave us in an uninitialized state
+// which will require a new call to InitRecording(). This test does not call
+// StartRecording() while being uninitialized since doing so will hit a
+// RTC_DCHECK and death tests are not supported on Android.
+TEST_F(AudioDeviceTest, StopRecordingRequiresInitToRestart) {
+  EXPECT_EQ(0, audio_device()->InitRecording());
+  EXPECT_EQ(0, audio_device()->StartRecording());
+  EXPECT_EQ(0, audio_device()->StopRecording());
+  EXPECT_FALSE(audio_device()->RecordingIsInitialized());
+}
+
 // Start playout and verify that the native audio layer starts asking for real
 // audio samples to play out using the NeedMorePlayData callback.
 TEST_F(AudioDeviceTest, StartPlayoutVerifyCallbacks) {
   MockAudioTransport mock(kPlayout);
   mock.HandleCallbacks(test_is_done_.get(), nullptr, kNumCallbacks);
   EXPECT_CALL(mock, NeedMorePlayData(playout_frames_per_10ms_buffer(),
                                      kBytesPerSample,
                                      playout_channels(),
                                      playout_sample_rate(),
                                      NotNull(),
@@ skipping 143 matching lines @@
   StopPlayout();
   StopRecording();
   // Verify that the correct number of transmitted impulses are detected.
   EXPECT_EQ(latency_audio_stream->num_latency_values(),
             static_cast<size_t>(
                 kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1));
   latency_audio_stream->PrintResults();
 }
 
 }  // namespace webrtc