Handle the dual microphones and dual cameras cases. Activate the proper microphone when user activa…

chromeos/audio/cras_audio_handler_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/audio/cras_audio_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromeos/audio/audio_devices_pref_handler.h"
 #include "chromeos/audio/audio_devices_pref_handler_stub.h"
 #include "chromeos/dbus/audio_node.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cras_audio_client.h"
+#include "media/base/video_facing.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace {
 
 const uint64_t kInternalSpeakerId = 10001;
 const uint64_t kHeadphoneId = 10002;
 const uint64_t kInternalMicId = 10003;
 const uint64_t kUSBMicId = 10004;
 const uint64_t kBluetoothHeadsetId = 10005;
 const uint64_t kHDMIOutputId = 10006;
 const uint64_t kUSBHeadphoneId1 = 10007;
 const uint64_t kUSBHeadphoneId2 = 10008;
 const uint64_t kMicJackId = 10009;
 const uint64_t kKeyboardMicId = 10010;
+const uint64_t kFrontMicId = 10011;
+const uint64_t kRearMicId = 10012;
 const uint64_t kOtherTypeOutputId = 90001;
 const uint64_t kOtherTypeInputId = 90002;
 const uint64_t kUSBJabraSpeakerOutputId1 = 90003;
 const uint64_t kUSBJabraSpeakerOutputId2 = 90004;
 const uint64_t kUSBJabraSpeakerInputId1 = 90005;
 const uint64_t kUSBJabraSpeakerInputId2 = 90006;
 const uint64_t kUSBCameraInputId = 90007;
 
 struct AudioNodeInfo {
   bool is_input;
@@ skipping 15 matching lines @@
 const AudioNodeInfo kMicJack[] = {
     {true, kMicJackId, "Fake Mic Jack", "MIC", "Mic Jack"}};
 
 const AudioNodeInfo kUSBMic[] = {
     {true, kUSBMicId, "Fake USB Mic", "USB", "USB Microphone"}};
 
 const AudioNodeInfo kKeyboardMic[] = {{true, kKeyboardMicId,
                                        "Fake Keyboard Mic", "KEYBOARD_MIC",
                                        "Keyboard Mic"}};
 
+const AudioNodeInfo kFrontMic[] = {
+    {true, kFrontMicId, "Fake Front Mic", "FRONT_MIC", "Front Mic"}};
+
+const AudioNodeInfo kRearMic[] = {
+    {true, kRearMicId, "Fake Rear Mic", "REAR_MIC", "Rear Mic"}};
+
 const AudioNodeInfo kOtherTypeOutput[] = {{false, kOtherTypeOutputId,
                                            "Output Device", "SOME_OTHER_TYPE",
                                            "Other Type Output Device"}};
 
 const AudioNodeInfo kOtherTypeInput[] = {{true, kOtherTypeInputId,
                                           "Input Device", "SOME_OTHER_TYPE",
                                           "Other Type Input Device"}};
 
 const AudioNodeInfo kBluetoothHeadset[] = {{false, kBluetoothHeadsetId,
                                             "Bluetooth Headset", "BLUETOOTH",
@@ skipping 120 matching lines @@
   int output_mute_changed_count_ = 0;
   int input_mute_changed_count_ = 0;
   int output_volume_changed_count_ = 0;
   int input_gain_changed_count_ = 0;
   bool output_mute_by_system_ = false;  // output mute state adjusted by system.
   int output_channel_remixing_changed_count_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
+class FakeVideoCaptureManager {
+ public:
+  FakeVideoCaptureManager() {}
+  virtual ~FakeVideoCaptureManager() {}
+
+  void AddObserver(media::VideoCaptureObserver* observer) {
+    observers_.AddObserver(observer);
+  }
+
+  void RemoveAllObservers() { observers_.Clear(); }
+
+  void NotifyVideoCaptureStarted(media::VideoFacingMode facing) {
+    for (auto& observer : observers_)
+      observer.OnVideoCaptureStarted(facing);
+  }
+
+  void NotifyVideoCaptureStopped(media::VideoFacingMode facing) {
+    for (auto& observer : observers_)
+      observer.OnVideoCaptureStopped(facing);
+  }
+
+ private:
+  base::ObserverList<media::VideoCaptureObserver> observers_;
+  DISALLOW_COPY_AND_ASSIGN(FakeVideoCaptureManager);
+};
+
 }  // namespace
 
 // Test param is the version of stabel device id used by audio node.
 class CrasAudioHandlerTest : public testing::TestWithParam<int> {
  public:
   CrasAudioHandlerTest() {}
   ~CrasAudioHandlerTest() override {}
 
-  void SetUp() override {}
+  void SetUp() override {
+    video_capture_manager_.reset(new FakeVideoCaptureManager);
+  }
 
   void TearDown() override {
     cras_audio_handler_->RemoveAudioObserver(test_observer_.get());
     test_observer_.reset();
+    video_capture_manager_->RemoveAllObservers();
+    video_capture_manager_.reset();
     CrasAudioHandler::Shutdown();
     audio_pref_handler_ = nullptr;
     DBusThreadManager::Shutdown();
   }
 
   AudioNode GenerateAudioNode(const AudioNodeInfo* node_info) {
     uint64_t stable_device_id_v2 = GetParam() == 1 ? 0 : (node_info->id ^ 0xFF);
     uint64_t stable_device_id_v1 = node_info->id;
     return AudioNode(node_info->is_input, node_info->id, GetParam() == 2,
                      stable_device_id_v1, stable_device_id_v2,
@@ skipping 13 matching lines @@
   void SetUpCrasAudioHandler(const AudioNodeList& audio_nodes) {
     DBusThreadManager::Initialize();
     fake_cras_audio_client_ = static_cast<FakeCrasAudioClient*>(
         DBusThreadManager::Get()->GetCrasAudioClient());
     fake_cras_audio_client_->SetAudioNodesForTesting(audio_nodes);
     audio_pref_handler_ = new AudioDevicesPrefHandlerStub();
     CrasAudioHandler::Initialize(audio_pref_handler_);
     cras_audio_handler_ = CrasAudioHandler::Get();
     test_observer_.reset(new TestObserver);
     cras_audio_handler_->AddAudioObserver(test_observer_.get());
+    video_capture_manager_->AddObserver(cras_audio_handler_);
     base::RunLoop().RunUntilIdle();
   }
 
   // Set up cras audio handlers with |audio_nodes| and set the active state of
   // |active_device_in_pref| as active and |activate_by_user| in the pref,
   // and rest of nodes in |audio_nodes_in_pref| as inactive.
   void SetupCrasAudioHandlerWithActiveNodeInPref(
       const AudioNodeList& audio_nodes,
       const AudioNodeList& audio_nodes_in_pref,
       const AudioDevice& active_device_in_pref,
@@ skipping 71 matching lines @@
 
   bool IsDuringHDMIRediscoverGracePeriod() {
     return cras_audio_handler_->hdmi_rediscovering();
   }
 
   void RestartAudioClient() {
     cras_audio_handler_->AudioClientRestarted();
     base::RunLoop().RunUntilIdle();
   }
 
+  void StartFrontFacingCamera() {
+    video_capture_manager_->NotifyVideoCaptureStarted(
+        media::MEDIA_VIDEO_FACING_USER);
+  }
+
+  void StopFrontFacingCamera() {
+    video_capture_manager_->NotifyVideoCaptureStopped(
+        media::MEDIA_VIDEO_FACING_USER);
+  }
+
+  void StartRearFacingCamera() {
+    video_capture_manager_->NotifyVideoCaptureStarted(
+        media::MEDIA_VIDEO_FACING_ENVIRONMENT);
+  }
+
+  void StopRearFacingCamera() {
+    video_capture_manager_->NotifyVideoCaptureStopped(
+        media::MEDIA_VIDEO_FACING_ENVIRONMENT);
+  }
+
  protected:
   base::MessageLoopForUI message_loop_;
   CrasAudioHandler* cras_audio_handler_ = nullptr;         // Not owned.
   FakeCrasAudioClient* fake_cras_audio_client_ = nullptr;  // Not owned.
   std::unique_ptr<TestObserver> test_observer_;
   scoped_refptr<AudioDevicesPrefHandlerStub> audio_pref_handler_;
+  std::unique_ptr<FakeVideoCaptureManager> video_capture_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CrasAudioHandlerTest);
 };
 
 class HDMIRediscoverWaiter {
  public:
   HDMIRediscoverWaiter(CrasAudioHandlerTest* cras_audio_handler_test,
                        int grace_period_duration_in_ms)
       : cras_audio_handler_test_(cras_audio_handler_test),
@@ skipping 3306 matching lines @@
   EXPECT_TRUE(
       cras_audio_handler_->GetPrimaryActiveOutputDevice(&active_output));
   EXPECT_EQ(kInternalSpeaker->id, active_output.id);
   EXPECT_EQ(kInternalSpeaker->id,
             cras_audio_handler_->GetPrimaryActiveOutputNode());
   EXPECT_FALSE(cras_audio_handler_->IsOutputMuted());
   EXPECT_EQ(1, test_observer_->output_mute_changed_count());
   EXPECT_TRUE(test_observer_->output_mute_by_system());
 }
 
+TEST_P(CrasAudioHandlerTest, FrontCameraStartStop) {
+  AudioNodeList audio_nodes = GenerateAudioNodeList({kFrontMic, kRearMic});
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+  EXPECT_TRUE(cras_audio_handler_->HasDualInternalMic());
+
+  // Start the front facing camera.
+  StartFrontFacingCamera();
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Stop the front facing camera.
+  StopFrontFacingCamera();
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+}
+
+TEST_P(CrasAudioHandlerTest, RearCameraStartStop) {
+  AudioNodeList audio_nodes = GenerateAudioNodeList({kFrontMic, kRearMic});
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+  EXPECT_TRUE(cras_audio_handler_->HasDualInternalMic());
+
+  // Start the rear facing camera.
+  StartRearFacingCamera();
+  // Verify the active input is switched to the rear mic.
+  EXPECT_EQ(kRearMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Stop the rear facing camera.
+  StopRearFacingCamera();
+  // Verify the active input is switched back to front mic.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+}
+
+TEST_P(CrasAudioHandlerTest, SwitchFrontRearCamera) {
+  AudioNodeList audio_nodes = GenerateAudioNodeList({kFrontMic, kRearMic});
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+  EXPECT_TRUE(cras_audio_handler_->HasDualInternalMic());
+
+  // Start the front facing camera.
+  StartFrontFacingCamera();
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Simulates the camera app switching from front camera to rear camera.
+  StopFrontFacingCamera();
+  StartRearFacingCamera();
+
+  // Verify the rear mic has been selected as the active input.
+  EXPECT_EQ(kRearMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+}
+
+TEST_P(CrasAudioHandlerTest, StartFrontCameraWithActiveExternalInput) {
+  AudioNodeList audio_nodes =
+      GenerateAudioNodeList({kFrontMic, kRearMic, kMicJack});
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the mic Jack has been selected as the active input.
+  EXPECT_EQ(kMicJackId, cras_audio_handler_->GetPrimaryActiveInputNode());
+  EXPECT_TRUE(cras_audio_handler_->HasDualInternalMic());
+
+  // Start the front facing camera.
+  StartFrontFacingCamera();
+  // Verify the mic Jack has been selected as the active input.
+  EXPECT_EQ(kMicJackId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Stop the front facing camera.
+  StopFrontFacingCamera();
+  // Verify the mic Jack remains as the active input.
+  EXPECT_EQ(kMicJackId, cras_audio_handler_->GetPrimaryActiveInputNode());
+}
+
+TEST_P(CrasAudioHandlerTest, StartFrontCameraWithInactiveExternalInput) {
+  AudioNodeList audio_nodes =
+      GenerateAudioNodeList({kFrontMic, kRearMic, kMicJack});
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the mic Jack has been selected as the active input.
+  EXPECT_EQ(kMicJackId, cras_audio_handler_->GetPrimaryActiveInputNode());
+  EXPECT_TRUE(cras_audio_handler_->HasDualInternalMic());
+
+  // Change the active input to internal mic.
+  cras_audio_handler_->SwitchToFrontOrRearMic();
+  // Verify the active input has been switched to front mic.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Start the front facing camera.
+  StartFrontFacingCamera();
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Stop the front facing camera.
+  StopFrontFacingCamera();
+  // Verify the active input remains as front mic.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+}
+
+TEST_P(CrasAudioHandlerTest, StartFrontCameraWithoutDualMic) {
+  AudioNodeList audio_nodes = GenerateAudioNodeList({kInternalMic});
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the mic Jack has been selected as the active input.
+  EXPECT_EQ(kInternalMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+  EXPECT_FALSE(cras_audio_handler_->HasDualInternalMic());
+
+  // Start the front facing camera.
+  StartFrontFacingCamera();
+  // Verify the internal mic has been selected as the active input.
+  EXPECT_EQ(kInternalMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Stop the front facing camera.
+  StopFrontFacingCamera();
+  // Verify the active input remains as interanl mic.
+  EXPECT_EQ(kInternalMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+}
+
+TEST_P(CrasAudioHandlerTest, FrontRearCameraBothOn) {
+  AudioNodeList audio_nodes = GenerateAudioNodeList({kFrontMic, kRearMic});
+  SetUpCrasAudioHandler(audio_nodes);
+
+  // Verify the audio devices size.
+  AudioDeviceList audio_devices;
+  cras_audio_handler_->GetAudioDevices(&audio_devices);
+  EXPECT_EQ(audio_nodes.size(), audio_devices.size());
+
+  // Verify the front mic has been selected as the active input.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+  EXPECT_TRUE(cras_audio_handler_->HasDualInternalMic());
+
+  // Start the rear facing camera.
+  StartRearFacingCamera();
+  // Verify the rear mic has been selected as the active input.
+  EXPECT_EQ(kRearMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Start front camera without stopping the front camera.
+  StartFrontFacingCamera();
+  // Verify the active microphone does not change.
+  EXPECT_EQ(kRearMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Stop the front mic.
+  StopFrontFacingCamera();
+  // Verity the active mic does not change when there is still camera on.
+  EXPECT_EQ(kRearMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+
+  // Stop the rear mic.
+  StopRearFacingCamera();
+  // Verify the actice mic changes to front mic after both cameras stop.
+  EXPECT_EQ(kFrontMicId, cras_audio_handler_->GetPrimaryActiveInputNode());
+}
+
 }  // namespace chromeos