Store audio device's active state in preference

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 28 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_t node_id,
                   const CrasAudioHandler::NodeIdList& id_list) {
   return std::find(id_list.begin(), id_list.end(), node_id) != id_list.end();
 }
 
-bool IsNodeInTheList(uint64_t 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::OnOutputNodeVolumeChanged(
     uint64_t /* node_id */,
@@ skipping 227 matching lines @@
         make_input_change = true;
         RemoveActiveNodeInternal(device.id, false);  // no notification.
       } else if (!device.is_input && request_output_change &&
                  !IsInNodeList(device.id, new_active_ids)) {
         make_output_change = true;
         RemoveActiveNodeInternal(device.id, false);  // no notification.
       }
     }
   }
 
-  // Adds the new active devices.
+  // Adds the new active devices. Note that this function is used by audio
+  // extension to manage multiple active nodes, in which case the devices
+  // selection preference is controlled by the app, we intentionally exclude
+  // the additional nodes from saving their device states as a result.
   for (size_t i = 0; i < nodes_to_activate.size(); ++i)
     AddActiveNode(nodes_to_activate[i], false);  // no notification.
 
   // Notify the active nodes change now.
   if (make_input_change)
     NotifyActiveNodeChanged(true);
   if (make_output_change)
     NotifyActiveNodeChanged(false);
 }
 
@@ skipping 76 matching lines @@
   SetInputMuteInternal(mute_on);
   FOR_EACH_OBSERVER(AudioObserver, observers_,
                     OnInputMuteChanged(input_mute_on_));
 }
 
 void CrasAudioHandler::SetActiveOutputNode(uint64_t node_id, bool notify) {
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetActiveOutputNode(node_id);
   if (notify)
     NotifyActiveNodeChanged(false);
+
+  // Save state for all output nodes.
+  for (AudioDeviceMap::iterator it = audio_devices_.begin();
+       it != audio_devices_.end(); ++it) {
+    if (it->second.is_input)
+      continue;
+    audio_pref_handler_->SetDeviceState(it->second, it->second.active
+                                                        ? AUDIO_STATE_ACTIVE
+                                                        : AUDIO_STATE_INACTIVE);
+  }
 }
 
 void CrasAudioHandler::SetActiveInputNode(uint64_t node_id, bool notify) {
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetActiveInputNode(node_id);
   if (notify)
     NotifyActiveNodeChanged(true);
+
+  // Save state for all input nodes.
+  for (AudioDeviceMap::iterator it = audio_devices_.begin();
+       it != audio_devices_.end(); ++it) {
+    if (!it->second.is_input)
+      continue;
+    audio_pref_handler_->SetDeviceState(it->second, it->second.active
+                                                        ? AUDIO_STATE_ACTIVE
+                                                        : AUDIO_STATE_INACTIVE);
+  }
 }
 
 void CrasAudioHandler::SetVolumeGainPercentForDevice(uint64_t device_id,
                                                      int value) {
   const AudioDevice* device = GetDeviceFromId(device_id);
   if (!device)
     return;
 
   if (device->is_input)
     SetInputNodeGainPercent(device_id, value);
@@ skipping 356 matching lines @@
     SetupAudioInputState();
     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,
-                                       AudioNodeList* new_discovered) {
+bool CrasAudioHandler::HasDeviceChange(
+    const AudioNodeList& new_nodes,
+    bool is_input,
+    AudioDevicePriorityQueue* 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();
+  while (!new_discovered->empty())
+    new_discovered->pop();
   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);
       DeviceStatus status = CheckDeviceStatus(device);
       if (status == NEW_DEVICE)
-        new_discovered->push_back(*it);
+        new_discovered->push(device);
       if (status == NEW_DEVICE || status == CHANGED_DEVICE) {
         new_or_changed_device = true;
       }
     }
   }
   return new_or_changed_device || (num_old_devices != num_new_devices);
 }
 
 CrasAudioHandler::DeviceStatus CrasAudioHandler::CheckDeviceStatus(
     const AudioDevice& device) {
@@ skipping 25 matching lines @@
   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;
   }
 
-  AudioNodeList hotplug_output_nodes;
-  AudioNodeList hotplug_input_nodes;
+  AudioDevicePriorityQueue hotplug_output_nodes;
+  AudioDevicePriorityQueue 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();
@@ skipping 30 matching lines @@
   // or changed to inactive by cras, reset active_output_node_id_.
   // See crbug.com/478968.
   const AudioDevice* active_output = GetDeviceFromId(active_output_node_id_);
   if (!active_output || !active_output->active)
     active_output_node_id_ = 0;
   const AudioDevice* active_input = GetDeviceFromId(active_input_node_id_);
   if (!active_input || !active_input->active)
     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.
+  // devices, we wont't change the current active audio devices.
   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 {
-      // 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)) {
+      // If there is no current active node, or, no new hot plugged node, select
+      // the active node by their priorities.
+      if (!active_input_node_id_ || hotplug_input_nodes.empty()) {
         SwitchToDevice(input_devices_pq_.top(), true);
+      } else {
+        // If user has hot plugged any input nodes, look at the one with highest
+        // priority (normally, there is only one hot plugged input node), and
+        // consider switch to it depend on its last state stored in preference.
+        AudioDeviceState last_state =
+            audio_pref_handler_->GetDeviceState(hotplug_input_nodes.top());
+        switch (last_state) {
+          case AUDIO_STATE_ACTIVE:
+            // This node was plugged in before and was selected as the active
+            // one
+            // before it was unplugged last time, switch to this device.
+            SwitchToDevice(hotplug_input_nodes.top(), true);
+            break;
+          case AUDIO_STATE_NOT_AVAILABLE:
+            // This is a new node, not plugged in before, with the highest
+            // priority. Switch to this device.
+            if (input_devices_pq_.top().id == hotplug_input_nodes.top().id)
+              SwitchToDevice(hotplug_input_nodes.top(), true);
+            break;
+          case AUDIO_STATE_INACTIVE:
+          // This node was NOT selected as the active one last time before it
+          // got unplugged, so don't switch to it.
+          default:
+            break;
+        }
       }
     }
   }
   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.
+    // ditto input node logic.
     if (output_devices_pq_.empty()) {
       active_output_node_id_ = 0;
       NotifyActiveNodeChanged(false);
     } else {
-      // ditto input node case.
-      if (!active_output_node_id_ || hotplug_output_nodes.empty() ||
-          IsNodeInTheList(output_devices_pq_.top().id, hotplug_output_nodes)) {
+      if (!active_output_node_id_ || hotplug_output_nodes.empty()) {
         SwitchToDevice(output_devices_pq_.top(), true);
+      } else {
+        AudioDeviceState last_state =
+            audio_pref_handler_->GetDeviceState(hotplug_output_nodes.top());
+        switch (last_state) {
+          case AUDIO_STATE_ACTIVE:
+            SwitchToDevice(hotplug_output_nodes.top(), true);
+            break;
+          case AUDIO_STATE_NOT_AVAILABLE:
+            if (output_devices_pq_.top().id == hotplug_output_nodes.top().id)
+              SwitchToDevice(hotplug_output_nodes.top(), true);
+            break;
+          case AUDIO_STATE_INACTIVE:
+          default:
+            break;
+        }
       }
     }
   }
 }
 
 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 94 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