Implement HasInputDevices in CrasAudioManager

chromeos/audio/cras_audio_handler.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 <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "chromeos/audio/audio_devices_pref_handler.h"
 #include "chromeos/audio/audio_devices_pref_handler_stub.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "media/audio/audio_manager.h"
 
 using std::max;
 using std::min;
 
 namespace chromeos {
 
 namespace {
 
 // Default value for unmuting, as a percent in the range [0, 100].
 // Used when sound is unmuted, but volume was less than kMuteThresholdPercent.
@@ skipping 51 matching lines @@
 
 void CrasAudioHandler::AudioObserver::OnAudioNodesChanged() {
 }
 
 void CrasAudioHandler::AudioObserver::OnActiveOutputNodeChanged() {
 }
 
 void CrasAudioHandler::AudioObserver::OnActiveInputNodeChanged() {
 }
 
+CrasAudioHandler::AudioManagerWrapper::AudioManagerWrapper() {
+}
+CrasAudioHandler::AudioManagerWrapper::~AudioManagerWrapper() {
+}
+
+CrasAudioHandler::AudioManagerWrapperImpl::AudioManagerWrapperImpl() {
+}
+CrasAudioHandler::AudioManagerWrapperImpl::~AudioManagerWrapperImpl() {
+}
+
+void CrasAudioHandler::AudioManagerWrapperImpl::SetHasInputDevices(
+    bool has_input_devices) {
+  media::AudioManager::Get()->SetHasInputDevices(has_input_devices);
+}
+
+CrasAudioHandler::AudioManagerWrapperForTesting::
+    AudioManagerWrapperForTesting() {
+}
+CrasAudioHandler::AudioManagerWrapperForTesting::
+    ~AudioManagerWrapperForTesting() {
+}
+
+void CrasAudioHandler::AudioManagerWrapperForTesting::SetHasInputDevices(
+    bool has_input_devices) {
+}
+
 // static
 void CrasAudioHandler::Initialize(
-    scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) {
+    scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler,
+    scoped_ptr<AudioManagerWrapper> audio_manager) {
   CHECK(!g_cras_audio_handler);
-  g_cras_audio_handler = new CrasAudioHandler(audio_pref_handler);
+  g_cras_audio_handler =
+      new CrasAudioHandler(audio_pref_handler, audio_manager.Pass());
 }
 
 // static
 void CrasAudioHandler::InitializeForTesting() {
   CHECK(!g_cras_audio_handler);
-  CrasAudioHandler::Initialize(new AudioDevicesPrefHandlerStub());
+  scoped_ptr<AudioManagerWrapper> audio_manager(
+      new CrasAudioHandler::AudioManagerWrapperForTesting());
+  CrasAudioHandler::Initialize(new AudioDevicesPrefHandlerStub(),
+                               audio_manager.Pass());
 }
 
 // static
 void CrasAudioHandler::Shutdown() {
   CHECK(g_cras_audio_handler);
   delete g_cras_audio_handler;
   g_cras_audio_handler = NULL;
 }
 
 // static
@@ skipping 341 matching lines @@
   // Marks the start of the HDMI re-discovering grace period, during which we
   // will mute the audio output to prevent it to be be leaked to the
   // alternative output device.
   if ((hdmi_rediscovering_ && force_rediscovering) ||
       (!hdmi_rediscovering_ && IsHDMIPrimaryOutputDevice())) {
     StartHDMIRediscoverGracePeriod();
   }
 }
 
 CrasAudioHandler::CrasAudioHandler(
-    scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler)
+    scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler,
+    scoped_ptr<AudioManagerWrapper> audio_manager)
     : audio_pref_handler_(audio_pref_handler),
       output_mute_on_(false),
       input_mute_on_(false),
       output_volume_(0),
       input_gain_(0),
       active_output_node_id_(0),
       active_input_node_id_(0),
       has_alternative_input_(false),
       has_alternative_output_(false),
       output_mute_locked_(false),
       log_errors_(false),
       hdmi_rediscover_grace_period_duration_in_ms_(
           kHDMIRediscoverGracePeriodDurationInMs),
       hdmi_rediscovering_(false),
       weak_ptr_factory_(this) {
   if (!audio_pref_handler.get())
     return;
+  audio_manager_ = audio_manager.Pass();
   // If the DBusThreadManager or the CrasAudioClient aren't available, there
   // isn't much we can do. This should only happen when running tests.
   if (!chromeos::DBusThreadManager::IsInitialized() ||
       !chromeos::DBusThreadManager::Get() ||
       !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
     return;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->AddObserver(this);
   audio_pref_handler_->AddAudioPrefObserver(this);
   if (chromeos::DBusThreadManager::Get()->GetSessionManagerClient()) {
     chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
@@ skipping 442 matching lines @@
     } else {
       // ditto input node case.
       if (!active_output_node_id_ || hotplug_output_nodes.empty() ||
           IsNodeInTheList(output_devices_pq_.top().id, hotplug_output_nodes)) {
         SwitchToDevice(output_devices_pq_.top(), true);
       }
     }
   }
 }
 
+void CrasAudioHandler::UpdateAudioManagerHasInputDevices() {
+  AudioDeviceList devices;
+  GetAudioDevices(&devices);
+  for (size_t i = 0; i < devices.size(); ++i) {
+    if (devices[i].is_input && devices[i].is_for_simple_usage()) {
+      audio_manager_->SetHasInputDevices(true);
+      return;
+    }
+  }
+  audio_manager_->SetHasInputDevices(false);
+}
+
 void CrasAudioHandler::HandleGetNodes(const chromeos::AudioNodeList& node_list,
                                       bool success) {
   if (!success) {
     LOG_IF(ERROR, log_errors_) << "Failed to retrieve audio nodes data";
     return;
   }
 
   UpdateDevicesAndSwitchActive(node_list);
+  UpdateAudioManagerHasInputDevices();
   FOR_EACH_OBSERVER(AudioObserver, observers_, OnAudioNodesChanged());
 }
 
 void CrasAudioHandler::HandleGetNodesError(const std::string& error_name,
                                            const std::string& error_msg) {
   LOG_IF(ERROR, log_errors_) << "Failed to call GetNodes: "
       << error_name  << ": " << error_msg;
 }
 
 void CrasAudioHandler::AddAdditionalActiveNode(uint64_t node_id, bool notify) {
@@ skipping 76 matching lines @@
                      hdmi_rediscover_grace_period_duration_in_ms_),
       this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
 }
 
 void CrasAudioHandler::SetHDMIRediscoverGracePeriodForTesting(
     int duration_in_ms) {
   hdmi_rediscover_grace_period_duration_in_ms_ = duration_in_ms;
 }
 
 }  // namespace chromeos