Support hotwording on google.com and the new tab page.

chrome/browser/resources/hotword/state_manager.js

 // Copyright (c) 2014 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.
 
 cr.define('hotword', function() {
   'use strict';
 
   /**
+   * Trivial container class for session information.
+   * @constructor
+   * @struct
+   * @private
+   */
+  function Session_(source, triggerCb) {
+    this.source = source;
+    this.triggerCb = triggerCb;
+  }
+
+  /**
    * Class to manage hotwording state. Starts/stops the hotword detector based
    * on user settings, session requests, and any other factors that play into
    * whether or not hotwording should be running.
    * @constructor
    * @struct
    */
   function StateManager() {
     /**
      * Current state.
      * @private {hotword.StateManager.State_}
      */
     this.state_ = State_.STOPPED;
 
     /**
      * Current hotwording status.
      * @private {?chrome.hotwordPrivate.StatusDetails}
      */
     this.hotwordStatus_ = null;
 
     /**
      * NaCl plugin manager.
      * @private {?hotword.NaClManager}
      */
     this.pluginManager_ = null;
 
     /**
-     * Source of the current hotword session.
-     * @private {?hotword.constants.SessionSource}
+     * Currently active hotwording sessions.
+     * @private {!Array.<hotword.Session_>}
      */
-    this.sessionSource_ = null;
+    this.sessions_ = [];
 
     /**
-     * Callback to run when the hotword detector has successfully started.
-     * @private {!function()}
+     * Callbacks to run when the hotword detector has successfully started.
+     * @private {!Array.<function()>}
      */
-    this.sessionStartedCb_ = null;
+    this.sessionStartedCbs_ = [];

[rpetterson, 2014/09/25 02:23:38]

why aren't these stored in the Session_ type?

[Anand Mistry (off Chromium), 2014/09/25 05:23:42]

There could be cases where you have several of these outstanding for a single
session, and managing them separately would be better. Thinking about it a bit
more, it doesn't matter. Having a single one per session type would be clearer,
and allow it to be canceled when stopping a session.

+
+    /**
+     * Event that fires when the hotwording status has changed.
+     */
+    this.onStatusChanged = new chrome.Event();
 
     /**
      * Hotword trigger audio notification... a.k.a The Chime (tm).
      * @private {!Audio}
      */
     this.chime_ = document.createElement('audio');
 
     // Get the initial status.
     chrome.hotwordPrivate.getStatus(this.handleStatus_.bind(this));
 
@@ skipping 18 matching lines @@
   StateManager.prototype = {
     /**
      * Request status details update. Intended to be called from the
      * hotwordPrivate.onEnabledChanged() event.
      */
     updateStatus: function() {
       chrome.hotwordPrivate.getStatus(this.handleStatus_.bind(this));
     },
 
     /**
+     * @return {boolean} True if hotwording is enabled.
+     */
+    isEnabled: function() {
+      assert(this.hotwordStatus_);
+      return this.hotwordStatus_.enabled;
+    },
+
+    /**
+     * @return {boolean} True if always-on hotwording is enabled.
+     */
+    isAlwaysOnEnabled: function() {
+      assert(this.hotwordStatus_);
+      return this.hotwordStatus_.enabled &&
+          this.hotwordStatus_.alwaysOnEnabled;
+    },
+
+    /**
      * Callback for hotwordPrivate.getStatus() function.
      * @param {chrome.hotwordPrivate.StatusDetails} status Current hotword
      *     status.
      * @private
      */
     handleStatus_: function(status) {
       this.hotwordStatus_ = status;
       this.updateStateFromStatus_();
+
+      this.onStatusChanged.dispatch();
     },
 
     /**
      * Updates state based on the current status.
      * @private
      */
     updateStateFromStatus_: function() {
       if (!this.hotwordStatus_)
         return;
 
       if (this.hotwordStatus_.enabled) {
         // Start the detector if there's a session, and shut it down if there
         // isn't.
-        // TODO(amistry): Support stacking sessions. This can happen when the
-        // user opens google.com or the NTP, then opens the launcher. Opening
-        // google.com will create one session, and opening the launcher will
-        // create the second. Closing the launcher should re-activate the
-        // google.com session.
         // NOTE(amistry): With always-on, we want a different behaviour with
         // sessions since the detector should always be running. The exception
         // being when the user triggers by saying 'Ok Google'. In that case, the
         // detector stops, so starting/stopping the launcher session should
         // restart the detector.
-        if (this.sessionSource_)
+        if (this.sessions_.length)
           this.startDetector_();
         else
           this.shutdownDetector_();
       } else {
         // Not enabled. Shut down if running.
         this.shutdownDetector_();
       }
     },
 
     /**
@@ skipping 47 matching lines @@
      * Start the recognizer plugin. Assumes the plugin has been loaded and is
      * ready to start.
      * @private
      */
     startRecognizer_: function() {
       assert(this.pluginManager_);
       if (this.state_ != State_.RUNNING) {
         this.state_ = State_.RUNNING;
         this.pluginManager_.startRecognizer();
       }
-      if (this.sessionStartedCb_) {
-        this.sessionStartedCb_();
-        this.sessionStartedCb_ = null;
+      for (var i = 0; i < this.sessionStartedCbs_.length; i++) {
+        this.sessionStartedCbs_[i]();
       }
+      this.sessionStartedCbs_ = [];
     },
 
     /**
      * Shuts down and removes the plugin manager, if it exists.
      * @private
      */
     shutdownPluginManager_: function() {
       if (this.pluginManager_) {
         this.pluginManager_.shutdown();
         this.pluginManager_ = null;
@@ skipping 38 matching lines @@
      * @private
      */
     onTrigger_: function() {
       assert(this.pluginManager_);
       // Detector implicitly stops when the hotword is detected.
       this.state_ = State_.STOPPED;
 
       // Play the chime.
       this.chime_.play();
 
-      chrome.hotwordPrivate.notifyHotwordRecognition('search', function() {});
-
-      // Implicitly clear the session. A session needs to be started in order to
-      // restart the detector.
-      this.sessionSource_ = null;
-      this.sessionStartedCb_ = null;
+      // Implicitly clear the top session. A session needs to be started in
+      // order to restart the detector.
+      if (this.sessions_.length) {
+        var session = this.sessions_.pop();
+        if (session.triggerCb)
+          session.triggerCb();
+      }
     },
 
     /**
+     * Remove a hotwording session from the given source.
+     * @param {!hotword.constants.SessionSource} source Source of the hotword
+     *     session request.
+     * @private
+     */
+    removeSession_: function(source) {
+      for (var i = 0; i < this.sessions_.length; i++) {
+        if (this.sessions_[i].source == source) {
+          this.sessions_.splice(i, 1);
+          break;
+        }
+      }
+    },
+
+    /**
      * Start a hotwording session.
      * @param {!hotword.constants.SessionSource} source Source of the hotword
      *     session request.
      * @param {!function()} startedCb Callback invoked when the session has
      *     been started successfully.
      */
-    startSession: function(source, startedCb) {
-      this.sessionSource_ = source;
-      this.sessionStartedCb_ = startedCb;
+    startSession: function(source, startedCb, triggerCb) {
+      this.removeSession_(source);
+      this.sessions_.push(new Session_(source, triggerCb));
+      this.sessionStartedCbs_.push(startedCb);
       this.updateStateFromStatus_();
     },
 
     /**
      * Stops a hotwording session.
      * @param {!hotword.constants.SessionSource} source Source of the hotword
      *     session request.
      */
     stopSession: function(source) {
-      this.sessionSource_ = null;
-      this.sessionStartedCb_ = null;
+      this.removeSession_(source);
       this.updateStateFromStatus_();
     }
   };
 
   return {
     StateManager: StateManager
   };
 });