Start and stop the hotword detector when the user opens/closes the launcher.

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';
 
   /**
    * Class to manage hotwording state. Starts/stops the hotword detector based
    * on user settings, session requests, and any other factors that play into
@@ skipping 13 matching lines @@
      * @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}
+     */
+    this.sessionSource_ = null;
+
+    /**
+     * Callback to run when the hotword detector has successfully started.
+     * @private {!function()}
+     */
+    this.sessionStartedCb_ = null;
+
     // Get the initial status.
     chrome.hotwordPrivate.getStatus(this.handleStatus_.bind(this));
   }
 
   /**
    * @enum {number}
    * @private
    */
   StateManager.State_ = {
     STOPPED: 0,
@@ skipping 21 matching lines @@
     handleStatus_: function(status) {
       this.hotwordStatus_ = status;
       this.updateStateFromStatus_();
     },
 
     /**
      * Updates state based on the current status.
      * @private
      */
     updateStateFromStatus_: function() {
+      if (!this.hotwordStatus_)
+        return;
+
       if (this.hotwordStatus_.enabled) {
-        // Hotwording is enabled.
-        // TODO(amistry): Have a separate alwaysOnEnabled flag. For now, treat
-        // "enabled" as "always on enabled".
-        this.startDetector_();
+        // 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_)
+          this.startDetector_();
+        else
+          this.shutdownDetector_();
       } else {
         // Not enabled. Shut down if running.
         this.shutdownDetector_();
       }
     },
 
     /**
      * Starts the hotword detector.
      * @private
      */
@@ skipping 29 matching lines @@
                   this.shutdownPluginManager_();
                 }
               }.bind(this),
               function(error) {
                 this.state_ = State_.ERROR;
                 this.pluginManager_ = null;
               }.bind(this));
         }.bind(this));
       } else if (this.state_ != State_.STARTING) {
         // Don't try to start a starting detector.
-        this.state_ = State_.RUNNING;
-        this.pluginManager_.startRecognizer();
+        this.startRecognizer_();
       }
     },
 
     /**
+     * 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;
+      }
+    },
+
+    /**
      * Shuts down and removes the plugin manager, if it exists.
      * @private
      */
     shutdownPluginManager_: function() {
       if (this.pluginManager_) {
         this.pluginManager_.shutdown();
         this.pluginManager_ = null;
       }
     },
 
@@ skipping 11 matching lines @@
      * @private
      */
     onReady_: function() {
       if (this.state_ != State_.STARTING) {
         // At this point, we should not be in the RUNNING state. Doing so would
         // imply the hotword detector was started without being ready.
         assert(this.state_ != State_.RUNNING);
         this.shutdownPluginManager_();
         return;
       }
-      this.state_ = State_.RUNNING;
-      this.pluginManager_.startRecognizer();
+      this.startRecognizer_();
     },
 
     /**
      * Handle an error from the hotword plugin.
      * @private
      */
     onError_: function() {
       this.state_ = State_.ERROR;
       this.shutdownPluginManager_();
     },
 
     /**
      * Handle hotword triggering.
      * @private
      */
     onTrigger_: function() {
       assert(this.pluginManager_);
       // Detector implicitly stops when the hotword is detected.
       this.state_ = State_.STOPPED;
 
       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;
+    },
+
+    /**
+     * 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;
+      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.updateStateFromStatus_();
     }
   };
 
   return {
     StateManager: StateManager
   };
 });