Open the launcher when hotword is triggered in always-on mode.

BUG=397019

Review URL: https://codereview.chromium.org/631913004

Cr-Commit-Position: refs/heads/master@{#299859}

chrome/browser/extensions/api/hotword_private/hotword_private_api.cc

@@ -11,6 +11,8 @@
 #include "chrome/browser/search/hotword_client.h"
 #include "chrome/browser/search/hotword_service.h"
 #include "chrome/browser/search/hotword_service_factory.h"
+#include "chrome/browser/ui/app_list/app_list_service.h"
+#include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "extensions/browser/event_router.h"
@@ -157,8 +159,20 @@ bool HotwordPrivateSetHotwordSessionStateFunction::RunSync() {
 bool HotwordPrivateNotifyHotwordRecognitionFunction::RunSync() {
   HotwordService* hotword_service =
       HotwordServiceFactory::GetForProfile(GetProfile());
-  if (hotword_service && hotword_service->client())
-    hotword_service->client()->OnHotwordRecognized();
+  if (hotword_service) {
+    if (hotword_service->client()) {
+      hotword_service->client()->OnHotwordRecognized();
+    } else if (HotwordService::IsExperimentalHotwordingEnabled() &&
+               hotword_service->IsAlwaysOnEnabled()) {
+      Browser* browser = GetCurrentBrowser();
+      // If a Browser does not exist, fall back to the universally available,
+      // but not recommended, way.
+      AppListService* app_list_service = AppListService::Get(
+          browser ? browser->host_desktop_type() : chrome::GetActiveDesktop());
+      CHECK(app_list_service);
+      app_list_service->ShowForVoiceSearch(GetProfile());
+    }
+  }
   return true;
 }
 

chrome/browser/search/hotword_service.cc

@@ -438,6 +438,12 @@ bool HotwordService::IsOptedIntoAudioLogging() {
       profile_->GetPrefs()->GetBoolean(prefs::kHotwordAudioLoggingEnabled);
 }
 
+bool HotwordService::IsAlwaysOnEnabled() {
+  return
+      profile_->GetPrefs()->HasPrefPath(prefs::kHotwordAlwaysOnSearchEnabled) &&
+      profile_->GetPrefs()->GetBoolean(prefs::kHotwordAlwaysOnSearchEnabled);
+}
+
 void HotwordService::EnableHotwordExtension(
     ExtensionService* extension_service) {
   if (extension_service)
@@ -501,6 +507,9 @@ void HotwordService::StopHotwordSession(HotwordClient* client) {
   if (!IsServiceAvailable())
     return;
 
+  // Do nothing if there's no client.
+  if (!client_)
+    return;
   DCHECK(client_ == client);
 
   client_ = NULL;

chrome/browser/search/hotword_service.h

@@ -72,6 +72,9 @@ class HotwordService : public content::NotificationObserver,
   // is opted in, false otherwise..
   bool IsOptedIntoAudioLogging();
 
+  // Returns whether always-on hotwording is enabled.
+  bool IsAlwaysOnEnabled();
+
   // Control the state of the hotword extension.
   void EnableHotwordExtension(ExtensionService* extension_service);
   void DisableHotwordExtension(ExtensionService* extension_service);

chrome/browser/ui/app_list/app_list_service.h

@@ -77,6 +77,9 @@ class AppListService {
   // profile to local prefs as the default app list profile.
   virtual void ShowForProfile(Profile* requested_profile) = 0;
 
+  // Shows the app list, and jump to voice search. Used by always-on hotwording.
+  virtual void ShowForVoiceSearch(Profile* profile) = 0;
+
   // Shows the app list, and reveals the page that contains |extension_id|. This
   // should only be called for things that show in the app list, and only when
   // they begin or complete installing. If |start_discovery_tracking| is set,

chrome/browser/ui/app_list/app_list_service_disabled.cc

@@ -33,6 +33,7 @@ class AppListServiceDisabled : public AppListService {
 
   virtual void Show() override {}
   virtual void ShowForProfile(Profile* profile) override {}
+  virtual void ShowForVoiceSearch(Profile* profile) override {}
   virtual void ShowForAppInstall(Profile* profile,
                                  const std::string& extension_id,
                                  bool start_discovery_tracking) override {}

chrome/browser/ui/app_list/app_list_service_impl.cc

@@ -331,6 +331,11 @@ void AppListServiceImpl::Show() {
                  weak_factory_.GetWeakPtr()));
 }
 
+void AppListServiceImpl::ShowForVoiceSearch(Profile* profile) {
+  ShowForProfile(profile);
+  view_delegate_->ToggleSpeechRecognition();
+}
+
 void AppListServiceImpl::ShowForAppInstall(Profile* profile,
                                            const std::string& extension_id,
                                            bool start_discovery_tracking) {

chrome/browser/ui/app_list/app_list_service_impl.h

@@ -54,6 +54,7 @@ class AppListServiceImpl : public AppListService,
       const base::FilePath& user_data_dir) override;
   virtual void SetProfilePath(const base::FilePath& profile_path) override;
   virtual void Show() override;
+  virtual void ShowForVoiceSearch(Profile* profile) override;
   virtual void ShowForAppInstall(Profile* profile,
                                  const std::string& extension_id,
                                  bool start_discovery_tracking) override;

chrome/browser/ui/app_list/app_list_view_delegate.cc

@@ -472,8 +472,22 @@ void AppListViewDelegate::ViewClosing() {
     if (service->HotwordEnabled()) {
       HotwordService* hotword_service =
           HotwordServiceFactory::GetForProfile(profile_);
-      if (hotword_service)
+      if (hotword_service) {
         hotword_service->StopHotwordSession(this);
+
+        // If we're in always-on mode, we always want to restart hotwording
+        // after closing the launcher window. So, in always-on mode, hotwording
+        // is stopped, and then started again right away. Note that hotwording
+        // may already be stopped. The call to StopHotwordSession() above both
+        // explicitly stops hotwording, if it's running, and clears the
+        // association between the hotword service and |this|.  When starting up
+        // hotwording, pass nullptr as the client so that hotword triggers cause
+        // the launcher to open.
+        // TODO(amistry): This only works on ChromeOS since Chrome hides the
+        // launcher instead of destroying it. Make this work on Chrome.
+        if (hotword_service->IsAlwaysOnEnabled())
+          hotword_service->RequestHotwordSession(nullptr);
+      }
     }
   }
 }
@@ -519,6 +533,23 @@ void AppListViewDelegate::ToggleSpeechRecognition() {
       app_list::StartPageService::Get(profile_);
   if (service)
     service->ToggleSpeechRecognition();
+
+  // With the new hotword extension, stop the hotword session. With the launcher
+  // and NTP, this is unnecessary since the hotwording is implicitly stopped.
+  // However, for always on, hotword triggering launches the launcher which
+  // starts a session and hence starts the hotword detector. This results in the
+  // hotword detector and the speech-to-text engine running in parallel, which
+  // will conflict with each other (i.e. saying 'Ok Google' twice in a row
+  // should cause a search to happen for 'Ok Google', not two hotword triggers).
+  // To get around this, always stop the session when switching to speech
+  // recognition.
+  if (HotwordService::IsExperimentalHotwordingEnabled() &&
+      service && service->HotwordEnabled()) {
+    HotwordService* hotword_service =
+        HotwordServiceFactory::GetForProfile(profile_);
+    if (hotword_service)
+      hotword_service->StopHotwordSession(this);
+  }
 }
 
 void AppListViewDelegate::ShowForProfileByPath(
@@ -547,10 +578,12 @@ void AppListViewDelegate::OnSpeechRecognitionStateChanged(
   app_list::StartPageService* service =
       app_list::StartPageService::Get(profile_);
   // With the new hotword extension, we need to re-request hotwording after
-  // speech recognition has stopped.
+  // speech recognition has stopped. Do not request hotwording after the app
+  // list has already closed.
   if (new_state == app_list::SPEECH_RECOGNITION_READY &&
       HotwordService::IsExperimentalHotwordingEnabled() &&
-      service && service->HotwordEnabled()) {
+      service && service->HotwordEnabled() &&
+      controller_->GetAppListWindow()) {
     HotwordService* hotword_service =
         HotwordServiceFactory::GetForProfile(profile_);
     if (hotword_service) {

chrome/browser/ui/app_list/start_page_service.cc

@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/user_metrics.h"
@@ -111,7 +112,8 @@ StartPageService::StartPageService(Profile* profile)
       recommended_apps_(new RecommendedApps(profile)),
       state_(app_list::SPEECH_RECOGNITION_OFF),
       speech_button_toggled_manually_(false),
-      speech_result_obtained_(false) {
+      speech_result_obtained_(false),
+      webui_finished_loading_(false) {
   // If experimental hotwording is enabled, then we're always "ready".
   // Transitioning into the "hotword recognizing" state is handled by the
   // hotword extension.
@@ -154,9 +156,16 @@ void StartPageService::AppListHidden() {
 }
 
 void StartPageService::ToggleSpeechRecognition() {
+  DCHECK(contents_);
   speech_button_toggled_manually_ = true;
-  contents_->GetWebUI()->CallJavascriptFunction(
-      "appList.startPage.toggleSpeechRecognition");
+  if (webui_finished_loading_) {
+    contents_->GetWebUI()->CallJavascriptFunction(
+        "appList.startPage.toggleSpeechRecognition");
+  } else {
+    pending_webui_callbacks_.push_back(
+        base::Bind(&StartPageService::ToggleSpeechRecognition,
+                   base::Unretained(this)));
+  }
 }
 
 bool StartPageService::HotwordEnabled() {
@@ -228,6 +237,18 @@ void StartPageService::Shutdown() {
   UnloadContents();
 }
 
+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_)
+    cb.Run();
+  pending_webui_callbacks_.clear();
+}
+
 void StartPageService::LoadContents() {
   contents_.reset(content::WebContents::Create(
       content::WebContents::CreateParams(profile_)));
@@ -250,6 +271,7 @@ void StartPageService::LoadContents() {
 
 void StartPageService::UnloadContents() {
   contents_.reset();
+  webui_finished_loading_ = false;
 }
 
 }  // namespace app_list

chrome/browser/ui/app_list/start_page_service.h

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
@@ -43,6 +44,9 @@ class StartPageService : public KeyedService {
   void AppListHidden();
   void ToggleSpeechRecognition();
 
+  // Called when the WebUI has finished loading.
+  void WebUILoaded();
+
   // Returns true if the hotword is enabled in the app-launcher.
   bool HotwordEnabled();
 
@@ -89,6 +93,9 @@ class StartPageService : public KeyedService {
   bool speech_button_toggled_manually_;
   bool speech_result_obtained_;
 
+  bool webui_finished_loading_;
+  std::vector<base::Closure> pending_webui_callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(StartPageService);
 };
 

chrome/browser/ui/webui/app_list/start_page_handler.cc

@@ -160,6 +160,8 @@ void StartPageHandler::HandleInitialize(const base::ListValue* args) {
   if (!service)
     return;
 
+  service->WebUILoaded();
+
   recommended_apps_ = service->recommended_apps();
   recommended_apps_->AddObserver(this);