| // Copyright 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 used to manage the interaction between hotwording and the |
| * NTP/google.com. Injects a content script to interact with NTP/google.com |
| * and updates the global hotwording state based on interaction with those |
| * pages. |
| * @param {!hotword.StateManager} stateManager |
| * @constructor |
| */ |
| function PageAudioManager(stateManager) { |
| /** |
| * Manager of global hotwording state. |
| * @private {!hotword.StateManager} |
| */ |
| this.stateManager_ = stateManager; |
| |
| /** |
| * Mapping between tab ID and port that is connected from the injected |
| * content script. |
| * @private {!Object<number, Port>} |
| */ |
| this.portMap_ = {}; |
| |
| /** |
| * Chrome event listeners. Saved so that they can be de-registered when |
| * hotwording is disabled. |
| */ |
| this.connectListener_ = this.handleConnect_.bind(this); |
| this.tabCreatedListener_ = this.handleCreatedTab_.bind(this); |
| this.tabUpdatedListener_ = this.handleUpdatedTab_.bind(this); |
| this.tabActivatedListener_ = this.handleActivatedTab_.bind(this); |
| this.microphoneStateChangedListener_ = |
| this.handleMicrophoneStateChanged_.bind(this); |
| this.windowFocusChangedListener_ = this.handleChangedWindow_.bind(this); |
| this.messageListener_ = this.handleMessageFromPage_.bind(this); |
| |
| // Need to setup listeners on startup, otherwise events that caused the |
| // event page to start up, will be lost. |
| this.setupListeners_(); |
| |
| this.stateManager_.onStatusChanged.addListener(function() { |
| this.updateListeners_(); |
| this.updateTabState_(); |
| }.bind(this)); |
| }; |
| |
| var CommandToPage = hotword.constants.CommandToPage; |
| var CommandFromPage = hotword.constants.CommandFromPage; |
| |
| PageAudioManager.prototype = { |
| /** |
| * Helper function to test if a URL path is eligible for hotwording. |
| * @param {!string} url URL to check. |
| * @param {!string} base Base URL to compare against.. |
| * @return {boolean} True if url is an eligible hotword URL. |
| * @private |
| */ |
| checkUrlPathIsEligible_: function(url, base) { |
| if (url == base || |
| url == base + '/' || |
| url.indexOf(base + '/_/chrome/newtab?') == 0 || // Appcache NTP. |
| url.indexOf(base + '/?') == 0 || |
| url.indexOf(base + '/#') == 0 || |
| url.indexOf(base + '/webhp') == 0 || |
| url.indexOf(base + '/search') == 0 || |
| url.indexOf(base + '/imghp') == 0) { |
| return true; |
| } |
| return false; |
| }, |
| |
| /** |
| * Determines if a URL is eligible for hotwording. For now, the valid pages |
| * are the Google HP and SERP (this will include the NTP). |
| * @param {!string} url URL to check. |
| * @return {boolean} True if url is an eligible hotword URL. |
| * @private |
| */ |
| isEligibleUrl_: function(url) { |
| if (!url) |
| return false; |
| |
| var baseGoogleUrls = [ |
| 'https://encrypted.google.', |
| 'https://images.google.', |
| 'https://www.google.' |
| ]; |
| // TODO(amistry): Get this list from a file in the shared module instead. |
| var tlds = [ |
| 'at', |
| 'ca', |
| 'com', |
| 'com.au', |
| 'com.mx', |
| 'com.br', |
| 'co.jp', |
| 'co.kr', |
| 'co.nz', |
| 'co.uk', |
| 'co.za', |
| 'de', |
| 'es', |
| 'fr', |
| 'it', |
| 'ru' |
| ]; |
| |
| // Check for the new tab page first. |
| if (this.checkUrlPathIsEligible_(url, 'chrome://newtab')) |
| return true; |
| |
| // Check URLs with each type of local-based TLD. |
| for (var i = 0; i < baseGoogleUrls.length; i++) { |
| for (var j = 0; j < tlds.length; j++) { |
| var base = baseGoogleUrls[i] + tlds[j]; |
| if (this.checkUrlPathIsEligible_(url, base)) |
| return true; |
| } |
| } |
| return false; |
| }, |
| |
| /** |
| * Locates the current active tab in the current focused window and |
| * performs a callback with the tab as the parameter. |
| * @param {function(?Tab)} callback Function to call with the |
| * active tab or null if not found. The function's |this| will be set to |
| * this object. |
| * @private |
| */ |
| findCurrentTab_: function(callback) { |
| chrome.windows.getAll( |
| {'populate': true}, |
| function(windows) { |
| for (var i = 0; i < windows.length; ++i) { |
| if (!windows[i].focused) |
| continue; |
| |
| for (var j = 0; j < windows[i].tabs.length; ++j) { |
| var tab = windows[i].tabs[j]; |
| if (tab.active) { |
| callback.call(this, tab); |
| return; |
| } |
| } |
| } |
| callback.call(this, null); |
| }.bind(this)); |
| }, |
| |
| /** |
| * This function is called when a tab is activated (comes into focus). |
| * @param {Tab} tab Current active tab. |
| * @private |
| */ |
| activateTab_: function(tab) { |
| if (!tab) { |
| this.stopHotwording_(); |
| return; |
| } |
| if (tab.id in this.portMap_) { |
| this.startHotwordingIfEligible_(); |
| return; |
| } |
| this.stopHotwording_(); |
| this.prepareTab_(tab); |
| }, |
| |
| /** |
| * Prepare a new or updated tab by injecting the content script. |
| * @param {!Tab} tab Newly updated or created tab. |
| * @private |
| */ |
| prepareTab_: function(tab) { |
| if (!this.isEligibleUrl_(tab.url)) |
| return; |
| |
| chrome.tabs.executeScript( |
| tab.id, |
| {'file': 'audio_client.js'}, |
| function(results) { |
| if (chrome.runtime.lastError) { |
| // Ignore this error. For new tab pages, even though the URL is |
| // reported to be chrome://newtab/, the actual URL is a |
| // country-specific google domain. Since we don't have permission |
| // to inject on every page, an error will happen when the user is |
| // in an unsupported country. |
| // |
| // The property still needs to be accessed so that the error |
| // condition is cleared. If it isn't, exectureScript will log an |
| // error the next time it is called. |
| } |
| }); |
| }, |
| |
| /** |
| * Updates hotwording state based on the state of current tabs/windows. |
| * @private |
| */ |
| updateTabState_: function() { |
| this.findCurrentTab_(this.activateTab_); |
| }, |
| |
| /** |
| * Handles a newly created tab. |
| * @param {!Tab} tab Newly created tab. |
| * @private |
| */ |
| handleCreatedTab_: function(tab) { |
| this.prepareTab_(tab); |
| }, |
| |
| /** |
| * Handles an updated tab. |
| * @param {number} tabId Id of the updated tab. |
| * @param {{status: string}} info Change info of the tab. |
| * @param {!Tab} tab Updated tab. |
| * @private |
| */ |
| handleUpdatedTab_: function(tabId, info, tab) { |
| // Chrome fires multiple update events: undefined, loading and completed. |
| // We perform content injection on loading state. |
| if (info['status'] != 'loading') |
| return; |
| |
| this.prepareTab_(tab); |
| }, |
| |
| /** |
| * Handles a tab that has just become active. |
| * @param {{tabId: number}} info Information about the activated tab. |
| * @private |
| */ |
| handleActivatedTab_: function(info) { |
| this.updateTabState_(); |
| }, |
| |
| /** |
| * Handles the microphone state changing. |
| * @param {boolean} enabled Whether the microphone is now enabled. |
| * @private |
| */ |
| handleMicrophoneStateChanged_: function(enabled) { |
| if (enabled) { |
| this.updateTabState_(); |
| return; |
| } |
| |
| this.stopHotwording_(); |
| }, |
| |
| /** |
| * Handles a change in Chrome windows. |
| * Note: this does not always trigger in Linux. |
| * @param {number} windowId Id of newly focused window. |
| * @private |
| */ |
| handleChangedWindow_: function(windowId) { |
| this.updateTabState_(); |
| }, |
| |
| /** |
| * Handles a content script attempting to connect. |
| * @param {!Port} port Communications port from the client. |
| * @private |
| */ |
| handleConnect_: function(port) { |
| if (port.name != hotword.constants.CLIENT_PORT_NAME) |
| return; |
| |
| var tab = /** @type {!Tab} */(port.sender.tab); |
| // An existing port from the same tab might already exist. But that port |
| // may be from the previous page, so just overwrite the port. |
| this.portMap_[tab.id] = port; |
| port.onDisconnect.addListener(function() { |
| this.handleClientDisconnect_(port); |
| }.bind(this)); |
| port.onMessage.addListener(function(msg) { |
| this.handleMessage_(msg, port.sender, port.postMessage); |
| }.bind(this)); |
| }, |
| |
| /** |
| * Handles a client content script disconnect. |
| * @param {Port} port Disconnected port. |
| * @private |
| */ |
| handleClientDisconnect_: function(port) { |
| var tabId = port.sender.tab.id; |
| if (tabId in this.portMap_ && this.portMap_[tabId] == port) { |
| // Due to a race between port disconnection and tabs.onUpdated messages, |
| // the port could have changed. |
| delete this.portMap_[port.sender.tab.id]; |
| } |
| this.stopHotwordingIfIneligibleTab_(); |
| }, |
| |
| /** |
| * Disconnect all connected clients. |
| * @private |
| */ |
| disconnectAllClients_: function() { |
| for (var id in this.portMap_) { |
| var port = this.portMap_[id]; |
| port.disconnect(); |
| delete this.portMap_[id]; |
| } |
| }, |
| |
| /** |
| * Sends a command to the client content script on an eligible tab. |
| * @param {hotword.constants.CommandToPage} command Command to send. |
| * @param {number} tabId Id of the target tab. |
| * @private |
| */ |
| sendClient_: function(command, tabId) { |
| if (tabId in this.portMap_) { |
| var message = {}; |
| message[hotword.constants.COMMAND_FIELD_NAME] = command; |
| this.portMap_[tabId].postMessage(message); |
| } |
| }, |
| |
| /** |
| * Sends a command to all connected clients. |
| * @param {hotword.constants.CommandToPage} command Command to send. |
| * @private |
| */ |
| sendAllClients_: function(command) { |
| for (var idStr in this.portMap_) { |
| var id = parseInt(idStr, 10); |
| assert(!isNaN(id), 'Tab ID is not a number: ' + idStr); |
| this.sendClient_(command, id); |
| } |
| }, |
| |
| /** |
| * Handles a hotword trigger. Sends a trigger message to the currently |
| * active tab. |
| * @private |
| */ |
| hotwordTriggered_: function() { |
| this.findCurrentTab_(function(tab) { |
| if (tab) |
| this.sendClient_(CommandToPage.HOTWORD_VOICE_TRIGGER, tab.id); |
| }); |
| }, |
| |
| /** |
| * Starts hotwording. |
| * @private |
| */ |
| startHotwording_: function() { |
| this.stateManager_.startSession( |
| hotword.constants.SessionSource.NTP, |
| function() { |
| this.sendAllClients_(CommandToPage.HOTWORD_STARTED); |
| }.bind(this), |
| this.hotwordTriggered_.bind(this)); |
| }, |
| |
| /** |
| * Starts hotwording if the currently active tab is eligible for hotwording |
| * (e.g. google.com). |
| * @private |
| */ |
| startHotwordingIfEligible_: function() { |
| this.findCurrentTab_(function(tab) { |
| if (!tab) { |
| this.stopHotwording_(); |
| return; |
| } |
| if (this.isEligibleUrl_(tab.url)) |
| this.startHotwording_(); |
| }); |
| }, |
| |
| /** |
| * Stops hotwording. |
| * @private |
| */ |
| stopHotwording_: function() { |
| this.stateManager_.stopSession(hotword.constants.SessionSource.NTP); |
| this.sendAllClients_(CommandToPage.HOTWORD_ENDED); |
| }, |
| |
| /** |
| * Stops hotwording if the currently active tab is not eligible for |
| * hotwording (i.e. google.com). |
| * @private |
| */ |
| stopHotwordingIfIneligibleTab_: function() { |
| this.findCurrentTab_(function(tab) { |
| if (!tab) { |
| this.stopHotwording_(); |
| return; |
| } |
| if (!this.isEligibleUrl_(tab.url)) |
| this.stopHotwording_(); |
| }); |
| }, |
| |
| /** |
| * Handles a message from the content script injected into the page. |
| * @param {!Object} request Request from the content script. |
| * @param {!MessageSender} sender Message sender. |
| * @param {!function(Object)} sendResponse Function for sending a response. |
| * @private |
| */ |
| handleMessage_: function(request, sender, sendResponse) { |
| switch (request[hotword.constants.COMMAND_FIELD_NAME]) { |
| // TODO(amistry): Handle other messages such as CLICKED_RESUME and |
| // CLICKED_RESTART, if necessary. |
| case CommandFromPage.SPEECH_START: |
| this.stopHotwording_(); |
| break; |
| case CommandFromPage.SPEECH_END: |
| case CommandFromPage.SPEECH_RESET: |
| this.startHotwording_(); |
| break; |
| } |
| }, |
| |
| |
| /** |
| * Handles a message directly from the NTP/HP/SERP. |
| * @param {!Object} request Message from the sender. |
| * @param {!MessageSender} sender Information about the sender. |
| * @param {!function(HotwordStatus)} sendResponse Callback to respond |
| * to sender. |
| * @return {boolean} Whether to maintain the port open to call sendResponse. |
| * @private |
| */ |
| handleMessageFromPage_: function(request, sender, sendResponse) { |
| switch (request.type) { |
| case CommandFromPage.PAGE_WAKEUP: |
| if (sender.tab && this.isEligibleUrl_(sender.tab.url)) { |
| chrome.hotwordPrivate.getStatus( |
| true /* getOptionalFields */, |
| this.statusDone_.bind( |
| this, |
| request.tab || sender.tab || {incognito: true}, |
| sendResponse)); |
| return true; |
| } |
| |
| // Do not show the opt-in promo for ineligible urls. |
| this.sendResponse_({'doNotShowOptinMessage': true}, sendResponse); |
| break; |
| case CommandFromPage.CLICKED_OPTIN: |
| chrome.hotwordPrivate.setEnabled(true); |
| break; |
| // User has explicitly clicked 'no thanks'. |
| case CommandFromPage.CLICKED_NO_OPTIN: |
| chrome.hotwordPrivate.setEnabled(false); |
| break; |
| } |
| return false; |
| }, |
| |
| /** |
| * Sends a message directly to the sending page. |
| * @param {!HotwordStatus} response The response to send to the sender. |
| * @param {!function(HotwordStatus)} sendResponse Callback to respond |
| * to sender. |
| * @private |
| */ |
| sendResponse_: function(response, sendResponse) { |
| try { |
| sendResponse(response); |
| } catch (err) { |
| // Suppress the exception thrown by sendResponse() when the page doesn't |
| // specify a response callback in the call to |
| // chrome.runtime.sendMessage(). |
| // Unfortunately, there doesn't appear to be a way to detect one-way |
| // messages without explicitly saying in the message itself. This |
| // message is defined as a constant in |
| // extensions/renderer/messaging_bindings.cc |
| if (err.message == 'Attempting to use a disconnected port object') |
| return; |
| throw err; |
| } |
| }, |
| |
| /** |
| * Sends the response to the tab. |
| * @param {Tab} tab The tab that the request was sent from. |
| * @param {function(HotwordStatus)} sendResponse Callback function to |
| * respond to sender. |
| * @param {HotwordStatus} hotwordStatus Status of the hotword extension. |
| * @private |
| */ |
| statusDone_: function(tab, sendResponse, hotwordStatus) { |
| var response = {'doNotShowOptinMessage': true}; |
| |
| // If always-on is available, then we do not show the promo, as the promo |
| // only works with the sometimes-on pref. |
| if (!tab.incognito && hotwordStatus.available && |
| !hotwordStatus.enabledSet && !hotwordStatus.alwaysOnAvailable) { |
| response = hotwordStatus; |
| } |
| |
| this.sendResponse_(response, sendResponse); |
| }, |
| |
| /** |
| * Set up event listeners. |
| * @private |
| */ |
| setupListeners_: function() { |
| if (chrome.runtime.onConnect.hasListener(this.connectListener_)) |
| return; |
| |
| chrome.runtime.onConnect.addListener(this.connectListener_); |
| chrome.tabs.onCreated.addListener(this.tabCreatedListener_); |
| chrome.tabs.onUpdated.addListener(this.tabUpdatedListener_); |
| chrome.tabs.onActivated.addListener(this.tabActivatedListener_); |
| chrome.windows.onFocusChanged.addListener( |
| this.windowFocusChangedListener_); |
| chrome.hotwordPrivate.onMicrophoneStateChanged.addListener( |
| this.microphoneStateChangedListener_); |
| if (chrome.runtime.onMessage.hasListener(this.messageListener_)) |
| return; |
| chrome.runtime.onMessageExternal.addListener( |
| this.messageListener_); |
| }, |
| |
| /** |
| * Remove event listeners. |
| * @private |
| */ |
| removeListeners_: function() { |
| chrome.runtime.onConnect.removeListener(this.connectListener_); |
| chrome.tabs.onCreated.removeListener(this.tabCreatedListener_); |
| chrome.tabs.onUpdated.removeListener(this.tabUpdatedListener_); |
| chrome.tabs.onActivated.removeListener(this.tabActivatedListener_); |
| chrome.windows.onFocusChanged.removeListener( |
| this.windowFocusChangedListener_); |
| chrome.hotwordPrivate.onMicrophoneStateChanged.removeListener( |
| this.microphoneStateChangedListener_); |
| // Don't remove the Message listener, as we want them listening all |
| // the time, |
| }, |
| |
| /** |
| * Update event listeners based on the current hotwording state. |
| * @private |
| */ |
| updateListeners_: function() { |
| if (this.stateManager_.isSometimesOnEnabled()) { |
| this.setupListeners_(); |
| } else { |
| this.removeListeners_(); |
| this.stopHotwording_(); |
| this.disconnectAllClients_(); |
| } |
| } |
| }; |
| |
| return { |
| PageAudioManager: PageAudioManager |
| }; |
| }); |
