| // 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. |
| |
| cr.define('help', function() { |
| var Page = cr.ui.pageManager.Page; |
| var PageManager = cr.ui.pageManager.PageManager; |
| |
| /** |
| * Encapsulated handling of the channel change overlay. |
| */ |
| function ChannelChangePage() { |
| Page.call(this, 'channel-change-page', '', 'channel-change-page'); |
| } |
| |
| cr.addSingletonGetter(ChannelChangePage); |
| |
| ChannelChangePage.prototype = { |
| __proto__: Page.prototype, |
| |
| /** |
| * Name of the channel the device is currently on. |
| * @private |
| */ |
| currentChannel_: null, |
| |
| /** |
| * Name of the channel the device is supposed to be on. |
| * @private |
| */ |
| targetChannel_: null, |
| |
| /** |
| * True iff the device is enterprise-managed. |
| * @private |
| */ |
| isEnterpriseManaged_: undefined, |
| |
| /** |
| * List of the channels names, from the least stable to the most stable. |
| * @private |
| */ |
| channelList_: ['dev-channel', 'beta-channel', 'stable-channel'], |
| |
| /** |
| * List of the possible ui states. |
| * @private |
| */ |
| uiClassTable_: ['selected-channel-requires-powerwash', |
| 'selected-channel-requires-delayed-update', |
| 'selected-channel-good', |
| 'selected-channel-unstable'], |
| |
| /** override */ |
| initializePage: function() { |
| Page.prototype.initializePage.call(this); |
| |
| $('channel-change-page-cancel-button').onclick = |
| PageManager.closeOverlay.bind(PageManager); |
| |
| var self = this; |
| var options = this.getAllChannelOptions_(); |
| for (var i = 0; i < options.length; i++) { |
| var option = options[i]; |
| option.onclick = function() { |
| self.updateUI_(this.value); |
| }; |
| } |
| |
| $('channel-change-page-powerwash-button').onclick = function() { |
| self.setChannel_(self.getSelectedOption_(), true); |
| PageManager.closeOverlay(); |
| }; |
| |
| $('channel-change-page-change-button').onclick = function() { |
| self.setChannel_(self.getSelectedOption_(), false); |
| PageManager.closeOverlay(); |
| }; |
| }, |
| |
| /** @override */ |
| didShowPage: function() { |
| if (this.targetChannel_ != null) |
| this.selectOption_(this.targetChannel_); |
| else if (this.currentChannel_ != null) |
| this.selectOption_(this.currentChannel_); |
| var options = this.getAllChannelOptions_(); |
| for (var i = 0; i < options.length; i++) { |
| var option = options[i]; |
| if (option.checked) |
| option.focus(); |
| } |
| }, |
| |
| /** |
| * Returns the list of all radio buttons responsible for channel selection. |
| * @return {NodeList} Array of radio buttons |
| * @private |
| */ |
| getAllChannelOptions_: function() { |
| return this.pageDiv.querySelectorAll('input[type="radio"]'); |
| }, |
| |
| /** |
| * Returns value of the selected option. |
| * @return {?string} Selected channel name or null, if neither |
| * option is selected. |
| * @private |
| */ |
| getSelectedOption_: function() { |
| var options = this.getAllChannelOptions_(); |
| for (var i = 0; i < options.length; i++) { |
| var option = options[i]; |
| if (option.checked) |
| return option.value; |
| } |
| return null; |
| }, |
| |
| /** |
| * Selects option for a given channel. |
| * @param {string} channel Name of channel option that should be selected. |
| * @private |
| */ |
| selectOption_: function(channel) { |
| var options = this.getAllChannelOptions_(); |
| for (var i = 0; i < options.length; i++) { |
| var option = options[i]; |
| if (option.value == channel) { |
| option.checked = true; |
| } |
| } |
| this.updateUI_(channel); |
| }, |
| |
| /** |
| * Updates UI according to selected channel. |
| * @param {string} selectedChannel Selected channel |
| * @private |
| */ |
| updateUI_: function(selectedChannel) { |
| var currentStability = this.channelList_.indexOf(this.currentChannel_); |
| var newStability = this.channelList_.indexOf(selectedChannel); |
| |
| var newOverlayClass = null; |
| |
| if (selectedChannel == this.currentChannel_) { |
| if (this.currentChannel_ != this.targetChannel_) { |
| // Allow user to switch back to the current channel. |
| newOverlayClass = 'selected-channel-good'; |
| } |
| } else if (selectedChannel != this.targetChannel_) { |
| // Selected channel isn't equal to the current and target channel. |
| if (newStability > currentStability) { |
| // More stable channel is selected. For customer devices |
| // notify user about powerwash. |
| if (this.isEnterpriseManaged_) |
| newOverlayClass = 'selected-channel-requires-delayed-update'; |
| else |
| newOverlayClass = 'selected-channel-requires-powerwash'; |
| } else if (selectedChannel == 'dev-channel') { |
| // Warn user about unstable channel. |
| newOverlayClass = 'selected-channel-unstable'; |
| } else { |
| // Switching to the less stable channel. |
| newOverlayClass = 'selected-channel-good'; |
| } |
| } |
| |
| // Switch to the new UI state. |
| for (var i = 0; i < this.uiClassTable_.length; i++) |
| this.pageDiv.classList.remove(this.uiClassTable_[i]); |
| |
| if (newOverlayClass) |
| this.pageDiv.classList.add(newOverlayClass); |
| }, |
| |
| /** |
| * Sets the device target channel. |
| * @param {string} channel The name of the target channel |
| * @param {boolean} isPowerwashAllowed True iff powerwash is allowed |
| * @private |
| */ |
| setChannel_: function(channel, isPowerwashAllowed) { |
| this.targetChannel_ = channel; |
| this.updateUI_(channel); |
| help.HelpPage.setChannel(channel, isPowerwashAllowed); |
| }, |
| |
| /** |
| * Updates page UI according to device owhership policy. |
| * @param {boolean} isEnterpriseManaged True if the device is |
| * enterprise managed |
| * @private |
| */ |
| updateIsEnterpriseManaged_: function(isEnterpriseManaged) { |
| this.isEnterpriseManaged_ = isEnterpriseManaged; |
| }, |
| |
| /** |
| * Updates name of the current channel, i.e. the name of the |
| * channel the device is currently on. |
| * @param {string} channel The name of the current channel |
| * @private |
| */ |
| updateCurrentChannel_: function(channel) { |
| if (this.channelList_.indexOf(channel) < 0) |
| return; |
| this.currentChannel_ = channel; |
| this.selectOption_(channel); |
| }, |
| |
| /** |
| * Updates name of the target channel, i.e. the name of the |
| * channel the device is supposed to be in case of a pending |
| * channel change. |
| * @param {string} channel The name of the target channel |
| * @private |
| */ |
| updateTargetChannel_: function(channel) { |
| if (this.channelList_.indexOf(channel) < 0) |
| return; |
| this.targetChannel_ = channel; |
| }, |
| |
| /** |
| * @return {boolean} True if the page is ready and can be |
| * displayed, false otherwise |
| * @private |
| */ |
| isPageReady_: function() { |
| if (typeof this.isEnterpriseManaged_ == 'undefined') |
| return false; |
| if (!this.currentChannel_ || !this.targetChannel_) |
| return false; |
| return true; |
| }, |
| }; |
| |
| ChannelChangePage.updateIsEnterpriseManaged = function(isEnterpriseManaged) { |
| ChannelChangePage.getInstance().updateIsEnterpriseManaged_( |
| isEnterpriseManaged); |
| }; |
| |
| ChannelChangePage.updateCurrentChannel = function(channel) { |
| ChannelChangePage.getInstance().updateCurrentChannel_(channel); |
| }; |
| |
| ChannelChangePage.updateTargetChannel = function(channel) { |
| ChannelChangePage.getInstance().updateTargetChannel_(channel); |
| }; |
| |
| ChannelChangePage.isPageReady = function() { |
| return ChannelChangePage.getInstance().isPageReady_(); |
| }; |
| |
| // Export |
| return { |
| ChannelChangePage: ChannelChangePage |
| }; |
| }); |
