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.
 const int kDefaultUnmuteVolumePercent = 4;
 
 // Volume value which should be considered as muted in range [0, 100].
 const int kMuteThresholdPercent = 1;
 
 static CrasAudioHandler* g_cras_audio_handler = NULL;
 
+// audio_manager will point to a AudioManagerWrapperImpl object or
+// a mocked AudioManagerWrapper object for testing.
+static CrasAudioHandler::AudioManagerWrapper* audio_manager = NULL;

[Daniel Erat, 2015/06/23 14:15:49]

does this really need to be a global, or could it just be a regular member of
CrasAudioHandler?

[cychiang, 2015/06/24 08:11:29]

Done.
Now this manager needs to be passed through CrasAudioHandler::Initialize and
through the constructor of CrasAudioHandler.

+
 bool IsSameAudioDevice(const AudioDevice& a, const AudioDevice& b) {
   return a.id == b.id && a.is_input == b.is_input && a.type == b.type
       && a.device_name == b.device_name;
 }
 
 bool IsInNodeList(uint64_t node_id,
                   const CrasAudioHandler::NodeIdList& id_list) {
   return std::find(id_list.begin(), id_list.end(), node_id) != id_list.end();
 }
 
@@ skipping 31 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);
+}
+
+// static
+// Set audio manager wrapper for test. Must be called before Initialize

[Daniel Erat, 2015/06/23 14:15:49]

delete this comment; it's already present in the header

[cychiang, 2015/06/24 08:11:29]

Done.

+// for testing. CrasAudioHandler will delete this pointer at Shutdown.
+void CrasAudioHandler::SetUpAudioManagerWrapperForTesting(
+    AudioManagerWrapper* test_wrapper) {
+  DCHECK(!audio_manager);
+  audio_manager = test_wrapper;
+}
+
 // static
 void CrasAudioHandler::Initialize(
     scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) {
   CHECK(!g_cras_audio_handler);
   g_cras_audio_handler = new CrasAudioHandler(audio_pref_handler);
+  // Creates an AudioManagerWrapperImpl if audio_manager is not set
+  // by SetUpAudioManagerWrapperForTesting.
+  if (!audio_manager)
+    audio_manager = new CrasAudioHandler::AudioManagerWrapperImpl();
 }
 
 // static
 void CrasAudioHandler::InitializeForTesting() {
   CHECK(!g_cras_audio_handler);
   CrasAudioHandler::Initialize(new AudioDevicesPrefHandlerStub());
 }
 
 // static
 void CrasAudioHandler::Shutdown() {
   CHECK(g_cras_audio_handler);
   delete g_cras_audio_handler;
   g_cras_audio_handler = NULL;
+  CHECK(audio_manager);
+  delete audio_manager;
+  audio_manager = NULL;
 }
 
 // static
 bool CrasAudioHandler::IsInitialized() {
   return g_cras_audio_handler != NULL;
 }
 
 // static
 CrasAudioHandler* CrasAudioHandler::Get() {
   CHECK(g_cras_audio_handler)
@@ skipping 784 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::SetAudioManagerHasInputDevices(bool has_input_devices) {

[Daniel Erat, 2015/06/23 14:15:49]

this method is just one line; it seems simpler to just inline the call to
audio_manager->SetHasInputDevices() in UpdateAudioManagerHasInputDevices()

[cychiang, 2015/06/24 08:11:29]

Done.

+  audio_manager->SetHasInputDevices(has_input_devices);
+}
+
+void CrasAudioHandler::UpdateAudioManagerHasInputDevices() {
+  AudioDeviceList devices;
+  GetAudioDevices(&devices);
+  for (size_t i = 0; i < devices.size(); ++i) {
+    if (devices[i].is_input && devices[i].IsForSimpleUsage()) {
+      SetAudioManagerHasInputDevices(true);
+      return;
+    }
+  }
+  SetAudioManagerHasInputDevices(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 46 matching lines @@
       active_output_node_id_ = 0;
     chromeos::DBusThreadManager::Get()
         ->GetCrasAudioClient()
         ->RemoveActiveOutputNode(node_id);
     if (notify)
       NotifyActiveNodeChanged(false);
   }
 }
 
 }  // namespace chromeos