Moves ownership of OpenSL engine object to Android audio manager

webrtc/modules/audio_device/android/audio_manager_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.
  */
 
 #include <memory>
+#include <SLES/OpenSLES_Android.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/arraysize.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/modules/audio_device/android/build_info.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/android/ensure_initialized.h"
 
 #define PRINT(...) fprintf(stderr, __VA_ARGS__);
 
 namespace webrtc {
 
 static const char kTag[] = "  ";
@@ skipping 13 matching lines @@
   AudioManager* audio_manager() const { return audio_manager_.get(); }
 
   // A valid audio layer must always be set before calling Init(), hence we
   // might as well make it a part of the test fixture.
   void SetActiveAudioLayer() {
     EXPECT_EQ(0, audio_manager()->GetDelayEstimateInMilliseconds());
     audio_manager()->SetActiveAudioLayer(AudioDeviceModule::kAndroidJavaAudio);
     EXPECT_NE(0, audio_manager()->GetDelayEstimateInMilliseconds());
   }
 
+  // One way to ensure that the engine object is valid is to create an
+  // SL Engine interface since it exposes creation methods of all the OpenSL ES
+  // object types and it is only supported on the engine object. This method
+  // also verifies that the engine interface supports at least one interface.
+  // Note that, the test below is not a full test of the SLEngineItf object
+  // but only a simple sanity test to check that the global engine object is OK.
+  void ValidateSLEngine(SLObjectItf engine_object) {
+    EXPECT_NE(nullptr, engine_object);
+    // Get the SL Engine interface which is exposed by the engine object.
+    SLEngineItf engine;
+    SLresult result =
+        (*engine_object)->GetInterface(engine_object, SL_IID_ENGINE, &engine);
+    EXPECT_EQ(result, SL_RESULT_SUCCESS) << "GetInterface() on engine failed";
+    // Ensure that the SL Engine interface exposes at least one interface.
+    SLuint32 object_id = SL_OBJECTID_ENGINE;
+    SLuint32 num_supported_interfaces = 0;
+    result = (*engine)->QueryNumSupportedInterfaces(engine, object_id,
+                                                    &num_supported_interfaces);
+    EXPECT_EQ(result, SL_RESULT_SUCCESS)
+        << "QueryNumSupportedInterfaces() failed";
+    EXPECT_GE(num_supported_interfaces, 1u);
+  }
+
   std::unique_ptr<AudioManager> audio_manager_;
   AudioParameters playout_parameters_;
   AudioParameters record_parameters_;
 };
 
 TEST_F(AudioManagerTest, ConstructDestruct) {
 }
 
+// It should not be possible to create an OpenSL engine object if Java based
+// audio is requested in both directions.
+TEST_F(AudioManagerTest, GetOpenSLEngineShouldFailForJavaAudioLayer) {
+  audio_manager()->SetActiveAudioLayer(AudioDeviceModule::kAndroidJavaAudio);
+  SLObjectItf engine_object = audio_manager()->GetOpenSLEngine();
+  EXPECT_EQ(nullptr, engine_object);
+}
+
+// It should be possible to create an OpenSL engine object if OpenSL ES based
+// audio is requested in any direction.
+TEST_F(AudioManagerTest, GetOpenSLEngineShouldSucceedForOpenSLESAudioLayer) {
+  // List of supported audio layers that uses OpenSL ES audio.
+  const AudioDeviceModule::AudioLayer opensles_audio[] = {
+      AudioDeviceModule::kAndroidOpenSLESAudio,
+      AudioDeviceModule::kAndroidJavaInputAndOpenSLESOutputAudio};
+  // Verify that the global (singleton) OpenSL Engine can be acquired for all
+  // audio layes that uses OpenSL ES. Note that the engine is only created once.
+  for (const AudioDeviceModule::AudioLayer audio_layer : opensles_audio) {
+    audio_manager()->SetActiveAudioLayer(audio_layer);
+    SLObjectItf engine_object = audio_manager()->GetOpenSLEngine();
+    EXPECT_NE(nullptr, engine_object);
+    // Perform a simple sanity check of the created engine object.
+    ValidateSLEngine(engine_object);
+  }
+}
+
 TEST_F(AudioManagerTest, InitClose) {
   EXPECT_TRUE(audio_manager()->Init());
   EXPECT_TRUE(audio_manager()->Close());
 }
 
 TEST_F(AudioManagerTest, IsAcousticEchoCancelerSupported) {
   PRINT("%sAcoustic Echo Canceler support: %s\n", kTag,
         audio_manager()->IsAcousticEchoCancelerSupported() ? "Yes" : "No");
 }
 
@@ skipping 86 matching lines @@
             params.frames_per_10ms_buffer());
   EXPECT_EQ(kBytesPerFrame, params.GetBytesPerFrame());
   EXPECT_EQ(kBytesPerFrame * kFramesPerBuffer, params.GetBytesPerBuffer());
   EXPECT_EQ(kBytesPerFrame * kFramesPer10msBuffer,
             params.GetBytesPer10msBuffer());
   EXPECT_EQ(kBufferSizeInMs, params.GetBufferSizeInMilliseconds());
 }
 
 }  // namespace webrtc