Updates the mic icon status based on the device's audio state.

chrome/browser/ui/app_list/start_page_service.cc

 // Copyright 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 "chrome/browser/ui/app_list/start_page_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 18 matching lines @@
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "ui/app_list/app_list_switches.h"
 
+#if defined(OS_CHROMEOS)
+#include "chromeos/audio/cras_audio_handler.h"
+#endif
+
 using base::RecordAction;
 using base::UserMetricsAction;
 
 namespace app_list {
 
 namespace {
 
 bool InSpeechRecognition(SpeechRecognitionState state) {
   return state == SPEECH_RECOGNITION_RECOGNIZING ||
       state == SPEECH_RECOGNITION_IN_SPEECH;
 }
 
-}
+}  // namespace
 
 class StartPageService::ProfileDestroyObserver
     : public content::NotificationObserver {
  public:
   explicit ProfileDestroyObserver(StartPageService* service)
       : service_(service) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROFILE_DESTROYED,
                    content::Source<Profile>(service_->profile()));
   }
@@ skipping 33 matching lines @@
                                   const GURL& security_origin,
                                   content::MediaStreamType type) override {
     return MediaCaptureDevicesDispatcher::GetInstance()
         ->CheckMediaAccessPermission(web_contents, security_origin, type);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StartPageWebContentsDelegate);
 };
 
+#if defined(OS_CHROMEOS)
+
+class StartPageService::AudioStatus
+    : public chromeos::CrasAudioHandler::AudioObserver {
+ public:
+  explicit AudioStatus(StartPageService* start_page_service)
+      : start_page_service_(start_page_service) {
+    chromeos::CrasAudioHandler::Get()->AddAudioObserver(this);
+    CheckAndUpdate();
+  }
+
+  ~AudioStatus() override {
+    chromeos::CrasAudioHandler::Get()->RemoveAudioObserver(this);
+  }
+
+  bool CanListen() {
+    chromeos::CrasAudioHandler* audio_handler =
+        chromeos::CrasAudioHandler::Get();
+    return (audio_handler->GetPrimaryActiveInputNode() != 0) &&
+           !audio_handler->IsInputMuted();
+  }
+
+ private:
+  void CheckAndUpdate() {
+    // TODO(mukai): If the system can listen, this should also restart the
+    // hotword recognition.
+    start_page_service_->OnSpeechRecognitionStateChanged(
+        CanListen() ? SPEECH_RECOGNITION_READY : SPEECH_RECOGNITION_OFF);
+  }
+
+  // chromeos::CrasAudioHandler::AudioObserver:
+  void OnInputMuteChanged() override { CheckAndUpdate(); }
+
+  void OnActiveInputNodeChanged() override { CheckAndUpdate(); }
+
+  StartPageService* start_page_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioStatus);
+};
+
+#endif  // OS_CHROMEOS
+
 // static
 StartPageService* StartPageService::Get(Profile* profile) {
   return StartPageServiceFactory::GetForProfile(profile);
 }
 
 StartPageService::StartPageService(Profile* profile)
     : profile_(profile),
       profile_destroy_observer_(new ProfileDestroyObserver(this)),
       recommended_apps_(new RecommendedApps(profile)),
       state_(app_list::SPEECH_RECOGNITION_OFF),
       speech_button_toggled_manually_(false),
       speech_result_obtained_(false),
       webui_finished_loading_(false),
       weak_factory_(this) {
   // If experimental hotwording is enabled, then we're always "ready".
   // Transitioning into the "hotword recognizing" state is handled by the
   // hotword extension.
-  if (HotwordService::IsExperimentalHotwordingEnabled())
+  if (HotwordService::IsExperimentalHotwordingEnabled()) {
     state_ = app_list::SPEECH_RECOGNITION_READY;
+  }
 
   if (app_list::switches::IsExperimentalAppListEnabled())
     LoadContents();
 }
 
 StartPageService::~StartPageService() {}
 
 void StartPageService::AddObserver(StartPageObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void StartPageService::RemoveObserver(StartPageObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void StartPageService::AppListShown() {
   if (!contents_) {
     LoadContents();
   } else if (contents_->GetWebUI() &&
              !HotwordService::IsExperimentalHotwordingEnabled()) {
     // If experimental hotwording is enabled, don't call onAppListShown.
     // onAppListShown() initializes the web speech API, which is not used with
     // experimental hotwording.
     contents_->GetWebUI()->CallJavascriptFunction(
         "appList.startPage.onAppListShown",
         base::FundamentalValue(HotwordEnabled()));
   }
+
+#if defined(OS_CHROMEOS)
+  audio_status_.reset(new AudioStatus(this));
+#endif
 }
 
 void StartPageService::AppListHidden() {
   if (contents_->GetWebUI()) {
     contents_->GetWebUI()->CallJavascriptFunction(
         "appList.startPage.onAppListHidden");
   }
   if (!app_list::switches::IsExperimentalAppListEnabled())
     UnloadContents();
 
   if (HotwordService::IsExperimentalHotwordingEnabled() &&
       speech_recognizer_) {
     speech_recognizer_->Stop();
   }
+
+#if defined(OS_CHROMEOS)
+  audio_status_.reset();
+#endif
 }
 
 void StartPageService::ToggleSpeechRecognition() {
   DCHECK(contents_);
   speech_button_toggled_manually_ = true;
   if (!contents_->GetWebUI())
     return;
 
   if (!webui_finished_loading_) {
     pending_webui_callbacks_.push_back(
@@ skipping 69 matching lines @@
 }
 
 void StartPageService::OnSpeechSoundLevelChanged(int16_t level) {
   FOR_EACH_OBSERVER(StartPageObserver,
                     observers_,
                     OnSpeechSoundLevelChanged(level));
 }
 
 void StartPageService::OnSpeechRecognitionStateChanged(
     SpeechRecognitionState new_state) {
+#if defined(OS_CHROMEOS)
+  // Sometimes this can be called even though there are no audio input devices.
+  if (!audio_status_->CanListen())
+    new_state = SPEECH_RECOGNITION_OFF;
+#endif
+
+  if (state_ == new_state)
+    return;
 
   if (HotwordService::IsExperimentalHotwordingEnabled() &&
       new_state == SPEECH_RECOGNITION_READY &&
       speech_recognizer_) {
     speech_recognizer_->Stop();
   }
 
   if (!InSpeechRecognition(state_) && InSpeechRecognition(new_state)) {
     if (!speech_button_toggled_manually_ &&
         state_ == SPEECH_RECOGNITION_HOTWORD_LISTENING) {
@@ skipping 12 matching lines @@
                     observers_,
                     OnSpeechRecognitionStateChanged(new_state));
 }
 
 content::WebContents* StartPageService::GetSpeechContents() {
   return GetSpeechRecognitionContents();
 }
 
 void StartPageService::Shutdown() {
   UnloadContents();
+#if defined(OS_CHROMEOS)
+  audio_status_.reset();
+#endif
 }
 
 void StartPageService::WebUILoaded() {
   // There's a race condition between the WebUI loading, and calling its JS
   // functions. Specifically, calling LoadContents() doesn't mean that the page
   // has loaded, but several code paths make this assumption. This function
   // allows us to defer calling JS functions until after the page has finished
   // loading.
   webui_finished_loading_ = true;
   for (const auto& cb : pending_webui_callbacks_)
@@ skipping 20 matching lines @@
       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
       std::string());
 }
 
 void StartPageService::UnloadContents() {
   contents_.reset();
   webui_finished_loading_ = false;
 }
 
 }  // namespace app_list