Do not re-select active device if a lower priority device is hotplugged in and user has already sel…

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"
@@ skipping 21 matching lines @@
 
 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 node_id, const CrasAudioHandler::NodeIdList& id_list) {
   return std::find(id_list.begin(), id_list.end(), node_id) != id_list.end();
 }
 
+bool IsNodeInTheList(uint64 node_id, const AudioNodeList& node_list) {
+  for (size_t i = 0; i < node_list.size(); ++i) {
+    if (node_id == node_list[i].id)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 CrasAudioHandler::AudioObserver::AudioObserver() {
 }
 
 CrasAudioHandler::AudioObserver::~AudioObserver() {
 }
 
 void CrasAudioHandler::AudioObserver::OnOutputVolumeChanged() {
 }
@@ skipping 669 matching lines @@
     SetActiveInputNode(active_input_node_id_, notify);
   } else {
     if (!ChangeActiveDevice(device, &active_output_node_id_))
       return;
     SetupAudioOutputState();
     SetActiveOutputNode(active_output_node_id_, notify);
   }
 }
 
 bool CrasAudioHandler::HasDeviceChange(const AudioNodeList& new_nodes,
-                                       bool is_input) {
+                                       bool is_input,
+                                       AudioNodeList* new_discovered) {
   size_t num_old_devices = 0;
   size_t num_new_devices = 0;
   for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
        it != audio_devices_.end(); ++it) {
     if (is_input == it->second.is_input)
       ++num_old_devices;
   }
 
+  bool new_or_changed_device = false;
+  new_discovered->clear();
   for (AudioNodeList::const_iterator it = new_nodes.begin();
        it != new_nodes.end(); ++it) {
     if (is_input == it->is_input) {
       ++num_new_devices;
       // Look to see if the new device not in the old device list.
       AudioDevice device(*it);
-      if (FoundNewOrChangedDevice(device))
-        return true;
+      DeviceStatus status = CheckDeviceStatus(device);
+      if (status == NEW_DEVICE)
+        new_discovered->push_back(*it);
+      if (status == NEW_DEVICE || status == CHANGED_DEVICE) {
+        new_or_changed_device = true;
+      }
     }
   }
-  return num_old_devices != num_new_devices;
+  return new_or_changed_device || (num_old_devices != num_new_devices);
 }
 
-bool CrasAudioHandler::FoundNewOrChangedDevice(const AudioDevice& device) {
+CrasAudioHandler::DeviceStatus CrasAudioHandler::CheckDeviceStatus(
+    const AudioDevice& device) {
   const AudioDevice* device_found = GetDeviceFromId(device.id);
   if (!device_found)
-    return true;
+    return NEW_DEVICE;
 
   if (!IsSameAudioDevice(device, *device_found)) {
     LOG(WARNING) << "Different Audio devices with same id:"
         << " new device: " << device.ToString()
         << " old device: " << device_found->ToString();
-    return true;
+    return CHANGED_DEVICE;
   } else if (device.active != device_found->active) {
-    return true;
+    return CHANGED_DEVICE;
   }
 
-  return false;
+  return OLD_DEVICE;
 }
 
 void CrasAudioHandler::NotifyActiveNodeChanged(bool is_input) {
   if (is_input)
     FOR_EACH_OBSERVER(AudioObserver, observers_, OnActiveInputNodeChanged());
   else
     FOR_EACH_OBSERVER(AudioObserver, observers_, OnActiveOutputNodeChanged());
 }
 
 void CrasAudioHandler::UpdateDevicesAndSwitchActive(
     const AudioNodeList& nodes) {
   size_t old_output_device_size = 0;
   size_t old_input_device_size = 0;
   for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
        it != audio_devices_.end(); ++it) {
     if (it->second.is_input)
       ++old_input_device_size;
     else
       ++old_output_device_size;
   }
 
-  bool output_devices_changed = HasDeviceChange(nodes, false);
-  bool input_devices_changed = HasDeviceChange(nodes, true);
+  AudioNodeList hotplug_output_nodes;
+  AudioNodeList hotplug_input_nodes;
+  bool output_devices_changed =
+      HasDeviceChange(nodes, false, &hotplug_output_nodes);
+  bool input_devices_changed =
+      HasDeviceChange(nodes, true, &hotplug_input_nodes);
   audio_devices_.clear();
   has_alternative_input_ = false;
   has_alternative_output_ = false;
 
   while (!input_devices_pq_.empty())
     input_devices_pq_.pop();
   while (!output_devices_pq_.empty())
     output_devices_pq_.pop();
 
   size_t new_output_device_size = 0;
@@ skipping 15 matching lines @@
 
     if (device.is_input) {
       input_devices_pq_.push(device);
       ++new_input_device_size;
     } else {
       output_devices_pq_.push(device);
       ++new_output_device_size;
     }
   }
 
+  // If the previous active device is removed from the new node list,
+  // reset active_output_node_id_.
+  if (!GetDeviceFromId(active_output_node_id_))
+    active_output_node_id_ = 0;
+  if (!GetDeviceFromId(active_input_node_id_))
+    active_input_node_id_ = 0;
+
   // If audio nodes change is caused by unplugging some non-active audio
   // devices, the previously set active audio device will stay active.
   // Otherwise, switch to a new active audio device according to their priority.
   if (input_devices_changed &&
       !NonActiveDeviceUnplugged(old_input_device_size,
                                 new_input_device_size,
                                 active_input_node_id_)) {
     // Some devices like chromeboxes don't have the internal audio input. In
     // that case the active input node id should be reset.
     if (input_devices_pq_.empty()) {
       active_input_node_id_ = 0;
       NotifyActiveNodeChanged(true);
     } else {
-      SwitchToDevice(input_devices_pq_.top(), true);
+      // If user has hot plugged a new node, we should change to the active
+      // device to the new node if it has the highest priority; otherwise,
+      // we should keep the existing active node chosen by user.
+      // For all other cases, we will choose the node with highest priority.
+      if (!active_input_node_id_ || hotplug_input_nodes.empty() ||
+          IsNodeInTheList(input_devices_pq_.top().id, hotplug_input_nodes)) {
+        SwitchToDevice(input_devices_pq_.top(), true);
+      }
     }
   }
   if (output_devices_changed &&
       !NonActiveDeviceUnplugged(old_output_device_size,
                                 new_output_device_size,
                                 active_output_node_id_)) {
     // This is really unlikely to happen because all ChromeOS devices have the
     // internal audio output.
     if (output_devices_pq_.empty()) {
       active_output_node_id_ = 0;
       NotifyActiveNodeChanged(false);
     } else {
-      SwitchToDevice(output_devices_pq_.top(), true);
+      // 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::HandleGetNodes(const chromeos::AudioNodeList& node_list,
                                       bool success) {
   if (!success) {
     LOG_IF(ERROR, log_errors_) << "Failed to retrieve audio nodes data";
     return;
   }
@@ skipping 58 matching lines @@
       active_output_node_id_ = 0;
     chromeos::DBusThreadManager::Get()
         ->GetCrasAudioClient()
         ->RemoveActiveOutputNode(node_id);
     if (notify)
       NotifyActiveNodeChanged(false);
   }
 }
 
 }  // namespace chromeos