MD Settings: Bluetooth: Move device list to subpage

chrome/browser/resources/settings/bluetooth_page/bluetooth_subpage.js

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// Copyright 2017 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.
 
 /**
  * @fileoverview
- * 'settings-bluetooth-page' is the settings page for managing bluetooth
+ * 'settings-bluetooth-subpage' is the settings subpage for managing bluetooth
  *  properties and devices.
- *
- * Example:
- *    <core-animated-pages>
- *      <settings-bluetooth-page>
- *      </settings-bluetooth-page>
- *      ... other pages ...
- *    </core-animated-pages>
  */
 
-var bluetoothPage = bluetoothPage || {
-  /**
-   * Set this to provide a fake implementation for testing.
-   * @type {Bluetooth}
-   */
-  bluetoothApiForTest: null,
-
-  /**
-   * Set this to provide a fake implementation for testing.
-   * @type {BluetoothPrivate}
-   */
-  bluetoothPrivateApiForTest: null,
-};
-
 Polymer({
-  is: 'settings-bluetooth-page',
+  is: 'settings-bluetooth-subpage',
 
   behaviors: [I18nBehavior, CrScrollableBehavior],
 
   properties: {
-    /** Preferences state. */
-    prefs: {
-      type: Object,
+    /** Reflects the bluetooth-page property. */
+    bluetoothEnabled: {
+      type: Boolean,
       notify: true,
     },
 
-    /** @private */
-    bluetoothEnabled_: {
+    /**
+     * The bluetooth adapter state, cached by bluetooth-page.
+     * @type {!chrome.bluetooth.AdapterState|undefined}
+     */
+    adapterState: Object,
+
+    /** Informs bluetooth-page whether to show the spinner in the header. */
+    showSpinner: {
       type: Boolean,
-      value: false,
-      observer: 'bluetoothEnabledChanged_',
-    },
-
-    /** @private */
-    deviceListExpanded_: {
-      type: Boolean,
-      value: false,
+      notify: true,
+      computed: 'computeShowSpinner_(bluetoothEnabled, dialogId_)',
     },
 
     /**
-     * The cached bluetooth adapter state.
-     * @type {!chrome.bluetooth.AdapterState|undefined}
-     * @private
-     */
-    adapterState_: Object,
-
-    /**
-     * Whether or not a bluetooth device is connected.
-     * @private
-     */
-    deviceConnected_: Boolean,
-
-    /**
      * The ordered list of bluetooth devices.
      * @type {!Array<!chrome.bluetooth.Device>}
      * @private
      */
     deviceList_: {
       type: Array,
       value: function() {
         return [];
       },
     },
 
     /**
+     * The ordered list of paired or connecting bluetooth devices.
+     * @type {!Array<!chrome.bluetooth.Device>}
+     */
+    pairedDeviceList_: {
+      type: Array,
+      value: /** @return {Array} */ function() {
+        return [];
+      },
+    },
+
+    /**
      * Reflects the iron-list selecteditem property.
      * @type {!chrome.bluetooth.Device}
      * @private
      */
     selectedItem_: {
       type: Object,
       observer: 'selectedItemChanged_',
     },
 
     /**
      * Set to the name of the dialog to show. This page uses a single
      * paper-dialog to host one of three dialog elements, 'addDevice',
      * 'pairDevice', or 'connectError'. This allows a seamless transition
      * between dialogs. Note: This property should be set before opening the
      * dialog and setting the property will not itself cause the dialog to open.
      * @private
      */
-    dialogId_: String,
+    dialogId_: {
+      type: String,
+      value: '',
+    },
 
     /**
      * Current Pairing device.
-     * @type {?chrome.bluetooth.Device|undefined}
+     * @type {!chrome.bluetooth.Device|undefined}
      * @private
      */
     pairingDevice_: Object,
 
     /**
-     * Current Pairing event.
-     * @type {?chrome.bluetoothPrivate.PairingEvent|undefined}
-     * @private
-     */
-    pairingEvent_: Object,
-
-    /**
      * The translated error message to show when a connect error occurs.
      * @private
      */
     errorMessage_: String,
 
     /**
-     * Interface for bluetooth calls. May be overriden by tests.
+     * Interface for bluetooth calls. Set in bluetooth-page.
      * @type {Bluetooth}
      * @private
      */
     bluetooth: {
       type: Object,
       value: chrome.bluetooth,
     },
 
     /**
-     * Interface for bluetoothPrivate calls. May be overriden by tests.
+     * Interface for bluetoothPrivate calls. Set in bluetooth-page.
      * @type {BluetoothPrivate}
      * @private
      */
     bluetoothPrivate: {
       type: Object,
       value: chrome.bluetoothPrivate,
     },
   },
 
-  observers: ['deviceListChanged_(deviceList_.*)'],
-
-  /**
-   * Listener for chrome.bluetooth.onAdapterStateChanged events.
-   * @type {function(!chrome.bluetooth.AdapterState)|undefined}
-   * @private
-   */
-  bluetoothAdapterStateChangedListener_: undefined,
+  observers: [
+    'adapterStateChanged_(adapterState.*)',
+    'deviceListChanged_(deviceList_.*)',
+  ],
 
   /**
    * Listener for chrome.bluetooth.onBluetoothDeviceAdded/Changed events.
    * @type {function(!chrome.bluetooth.Device)|undefined}
    * @private
    */
   bluetoothDeviceUpdatedListener_: undefined,
 
   /**
    * Listener for chrome.bluetooth.onBluetoothDeviceRemoved events.
    * @type {function(!chrome.bluetooth.Device)|undefined}
    * @private
    */
   bluetoothDeviceRemovedListener_: undefined,
 
-  /**
-   * Listener for chrome.bluetoothPrivate.onPairing events.
-   * @type {function(!chrome.bluetoothPrivate.PairingEvent)|undefined}
-   * @private
-   */
-  bluetoothPrivateOnPairingListener_: undefined,
-
-  /** @override */
-  ready: function() {
-    if (bluetoothPage.bluetoothApiForTest)
-      this.bluetooth = bluetoothPage.bluetoothApiForTest;
-    if (bluetoothPage.bluetoothPrivateApiForTest)
-      this.bluetoothPrivate = bluetoothPage.bluetoothPrivateApiForTest;
-  },
-
   /** @override */
   attached: function() {
-    this.bluetoothAdapterStateChangedListener_ =
-        this.onBluetoothAdapterStateChanged_.bind(this);
-    this.bluetooth.onAdapterStateChanged.addListener(
-        this.bluetoothAdapterStateChangedListener_);
-
     this.bluetoothDeviceUpdatedListener_ =
         this.onBluetoothDeviceUpdated_.bind(this);
     this.bluetooth.onDeviceAdded.addListener(
         this.bluetoothDeviceUpdatedListener_);
     this.bluetooth.onDeviceChanged.addListener(
         this.bluetoothDeviceUpdatedListener_);
 
     this.bluetoothDeviceRemovedListener_ =
         this.onBluetoothDeviceRemoved_.bind(this);
     this.bluetooth.onDeviceRemoved.addListener(
         this.bluetoothDeviceRemovedListener_);
-
-    // Request the inital adapter state.
-    this.bluetooth.getAdapterState(this.bluetoothAdapterStateChangedListener_);
   },
 
   /** @override */
   detached: function() {
     if (this.bluetoothAdapterStateChangedListener_) {
       this.bluetooth.onAdapterStateChanged.removeListener(
           this.bluetoothAdapterStateChangedListener_);
     }
     if (this.bluetoothDeviceUpdatedListener_) {
       this.bluetooth.onDeviceAdded.removeListener(
           this.bluetoothDeviceUpdatedListener_);
       this.bluetooth.onDeviceChanged.removeListener(
           this.bluetoothDeviceUpdatedListener_);
     }
-    if (this.bluetoothDeviceRemovedListener_) {
-      this.bluetooth.onDeviceRemoved.removeListener(
-          this.bluetoothDeviceRemovedListener_);
-    }
   },
 
   /** @private */
-  bluetoothEnabledChanged_: function() {
-    // When bluetooth is enabled, auto-expand the device list.
-    if (this.bluetoothEnabled_)
-      this.deviceListExpanded_ = true;
+  computeShowSpinner_() {
+    return this.bluetoothEnabled && !this.dialogId_;

[fukino, 2017/01/30 08:44:01]

In system tray, spinner or infinite loader is shown only when the BT adapter is
discovering devices.
It might be better to be consistent with it?

[stevenjb, 2017/01/30 19:19:26]

Yeah, now that I think about it, the spinner doesn't really make sense here at
all. This is consistent with the previous behavior (except we hide it with the
dialog now because that looks terrible, it wasn't visible with the dialog
before). We can address this when we reconsider how we do 'add devices'.

+  },
+
+  /** @private */
+  adapterStateChanged_: function() {
+    this.updateDeviceList_();
   },
 
   /** @private */
   deviceListChanged_: function() {
-    for (var i = 0; i < this.deviceList_.length; ++i) {
-      if (this.deviceList_[i].connected) {
-        this.deviceConnected_ = true;
-        return;
-      }
-    }
-    this.deviceConnected_ = false;
+    var devices = this.$.devices;
+    this.pairedDeviceList_ = this.deviceList_.filter(function(device) {
+      return !!device.paired || !!device.connecting;
+    });
+    this.updateScrollableContents();
   },
 
   /** @private */
   selectedItemChanged_: function() {
     if (this.selectedItem_)
       this.connectDevice_(this.selectedItem_);
   },
 
   /**
-   * @return {string}
-   * @private
-   */
-  getIcon_: function() {
-    if (!this.bluetoothEnabled_)
-      return 'settings:bluetooth-disabled';
-    if (this.deviceConnected_)
-      return 'settings:bluetooth-connected';
-    return 'settings:bluetooth';
-  },
-
-  /**
-   * @return {string}
-   * @private
-   */
-  getTitle_: function() {
-    return this.i18n(
-        this.bluetoothEnabled_ ? 'bluetoothEnabled' : 'bluetoothDisabled');
-  },
-
-  /** @private */
-  toggleDeviceListExpanded_: function() {
-    this.deviceListExpanded_ = !this.deviceListExpanded_;
-  },
-
-  /**
-   * @return {boolean} Whether the <iron-collapse> can be shown.
-   * @private
-   */
-  canShowDeviceList_: function() {
-    return this.bluetoothEnabled_ && this.deviceListExpanded_;
-  },
-
-  /**
    * If bluetooth is enabled, request the complete list of devices and update
    * this.deviceList_.
    * @private
    */
   updateDeviceList_: function() {
-    if (!this.bluetoothEnabled_) {
+    if (!this.bluetoothEnabled) {
       this.deviceList_ = [];
       return;
     }
     this.bluetooth.getDevices(function(devices) {
       this.deviceList_ = devices;
-      this.updateScrollableContents();
     }.bind(this));
   },
 
   /**
-   * Event called when a user action changes the bluetoothEnabled state.
-   * @private
-   */
-  onBluetoothEnabledChange_: function() {
-    this.bluetoothPrivate.setAdapterState(
-        {powered: this.bluetoothEnabled_}, function() {
-          if (chrome.runtime.lastError) {
-            console.error(
-                'Error enabling bluetooth: ' +
-                chrome.runtime.lastError.message);
-          }
-        });
-  },
-
-  /**
-   * Process bluetooth.onAdapterStateChanged events.
-   * @param {!chrome.bluetooth.AdapterState} state
-   * @private
-   */
-  onBluetoothAdapterStateChanged_: function(state) {
-    this.adapterState_ = state;
-    this.bluetoothEnabled_ = state.powered;
-    this.updateDeviceList_();
-  },
-
-  /**
    * Process bluetooth.onDeviceAdded and onDeviceChanged events.
    * @param {!chrome.bluetooth.Device} device
    * @private
    */
   onBluetoothDeviceUpdated_: function(device) {
     var address = device.address;
     if (this.dialogId_ && this.pairingDevice_ &&
         this.pairingDevice_.address == address) {
       this.pairingDevice_ = device;
     }
-    var index = this.getDeviceIndex_(address);
+    var index = this.deviceList_.findIndex(function(device) {
+      return device.address == address;
+    });
     if (index >= 0) {
       this.set('deviceList_.' + index, device);
       return;
     }
     this.push('deviceList_', device);
   },
 
   /**
    * Process bluetooth.onDeviceRemoved events.
    * @param {!chrome.bluetooth.Device} device
    * @private
    */
   onBluetoothDeviceRemoved_: function(device) {
     var address = device.address;
-    var index = this.getDeviceIndex_(address);
-    if (index < 0)
-      return;
-    this.splice('deviceList_', index, 1);
+    var index = this.deviceList_.findIndex(function(device) {
+      return device.address == address;
+    });
+    if (index >= 0)
+      this.splice('deviceList_', index, 1);
   },
 
   /** @private */
   startDiscovery_: function() {
-    if (!this.adapterState_ || this.adapterState_.discovering)
+    if (!this.adapterState || this.adapterState.discovering)
       return;
 
-    if (!this.bluetoothPrivateOnPairingListener_) {
-      this.bluetoothPrivateOnPairingListener_ =
-          this.onBluetoothPrivateOnPairing_.bind(this);
-      this.bluetoothPrivate.onPairing.addListener(
-          this.bluetoothPrivateOnPairingListener_);
-    }
-
     this.bluetooth.startDiscovery(function() {
-      if (chrome.runtime.lastError) {
-        if (chrome.runtime.lastError.message == 'Failed to stop discovery') {
-          // May happen if also started elsewhere; ignore.
-          return;
-        }
-        console.error(
-            'startDiscovery Error: ' + chrome.runtime.lastError.message);
+      var lastError = chrome.runtime.lastError;
+      if (lastError) {
+        if (lastError.message == 'Starting discovery failed')
+          return;  // May happen if also started elsewhere, ignore.
+        console.error('startDiscovery Error: ' + lastError.message);
       }
     });
   },
 
   /** @private */
   stopDiscovery_: function() {
-    if (!this.get('adapterState_.discovering'))
+    if (!this.get('adapterState.discovering'))
       return;
 
-    if (this.bluetoothPrivateOnPairingListener_) {
-      this.bluetoothPrivate.onPairing.removeListener(
-          this.bluetoothPrivateOnPairingListener_);
-      this.bluetoothPrivateOnPairingListener_ = undefined;
-    }
-
     this.bluetooth.stopDiscovery(function() {
-      if (chrome.runtime.lastError) {
-        console.error(
-            'Error stopping bluetooth discovery: ' +
-            chrome.runtime.lastError.message);
+      var lastError = chrome.runtime.lastError;
+      if (lastError) {
+        if (lastError.message == 'Failed to stop discovery')
+          return;  // May happen if also stopped elsewhere, ignore.
+        console.error('stopDiscovery Error: ' + lastError.message);
       }
     });
   },
 
   /**
-   * Process bluetoothPrivate.onPairing events.
-   * @param {!chrome.bluetoothPrivate.PairingEvent} e
-   * @private
-   */
-  onBluetoothPrivateOnPairing_: function(e) {
-    if (!this.dialogId_ || !this.pairingDevice_ ||
-        e.device.address != this.pairingDevice_.address) {
-      return;
-    }
-    if (e.pairing == chrome.bluetoothPrivate.PairingEventType.KEYS_ENTERED &&
-        e.passkey === undefined && this.pairingEvent_) {
-      // 'keysEntered' event might not include the updated passkey so preserve
-      // the current one.
-      e.passkey = this.pairingEvent_.passkey;
-    }
-    this.pairingEvent_ = e;
-  },
-
-  /**
    * @param {!Event} e
    * @private
    */
   onAddDeviceTap_: function(e) {
     e.preventDefault();
     this.openDialog_('addDevice');
   },
 
   /**
    * @param {!{detail: {action: string, device: !chrome.bluetooth.Device}}} e
    * @private
    */
   onDeviceEvent_: function(e) {
     var action = e.detail.action;
     var device = e.detail.device;
     if (action == 'connect')
       this.connectDevice_(device);
     else if (action == 'disconnect')
       this.disconnectDevice_(device);
     else if (action == 'remove')
       this.forgetDevice_(device);
     else
       console.error('Unexected action: ' + action);
   },
 
   /**
-   * Handle a response sent from the pairing dialog and pass it to the
-   * bluetoothPrivate API.
-   * @param {Event} e
+   * @return {string}
    * @private
    */
-  onResponse_: function(e) {
-    var options =
-        /** @type {!chrome.bluetoothPrivate.SetPairingResponseOptions} */ (
-            e.detail);
-    this.bluetoothPrivate.setPairingResponse(options, function() {
-      if (chrome.runtime.lastError) {
-        // TODO(stevenjb): Show error.
-        console.error(
-            'Error setting pairing response: ' + options.device.name +
-            ': Response: ' + options.response +
-            ': Error: ' + chrome.runtime.lastError.message);
-      }
-      this.$$('#deviceDialog').close();
-    }.bind(this));
+  getOffOnString_() {
+    return this.i18n(this.bluetoothEnabled ? 'bluetoothOn' : 'bluetoothOff');
   },
 
   /**
-   * @param {string} address
-   * @return {number} The index of the device associated with |address| or -1.
+   * @return {boolean}
    * @private
    */
-  getDeviceIndex_: function(address) {
-    var len = this.deviceList_.length;
-    for (var i = 0; i < len; ++i) {
-      if (this.deviceList_[i].address == address)
-        return i;
-    }
-    return -1;
+  showDevices_: function() {
+    return this.bluetoothEnabled && this.pairedDeviceList_.length > 0;
   },
 
   /**
-   * @param {!chrome.bluetooth.Device} device
-   * @return {string} The text to display for |device| in the device list.
+   * @return {boolean}
    * @private
    */
-  getDeviceName_: function(device) {
-    return device.name || device.address;
+  showNoDevices_: function() {
+    return this.bluetoothEnabled && this.pairedDeviceList_.length == 0;
   },
 
   /**
-   * @return {!Array<!chrome.bluetooth.Device>}
-   * @private
-   */
-  getPairedOrConnecting_: function() {
-    return this.deviceList_.filter(function(device) {
-      return !!device.paired || !!device.connecting;
-    });
-  },
-
-  /**
-   * @return {boolean} True if deviceList contains any paired devices.
-   * @private
-   */
-  haveDevices_: function() {
-    return this.deviceList_.findIndex(function(d) {
-      return !!d.paired;
-    }) != -1;
-  },
-
-  /**
    * @param {!chrome.bluetooth.Device} device
    * @private
    */
   connectDevice_: function(device) {
-    // If the device is not paired, show the pairing dialog.
+    // If the device is not paired, show the pairing dialog before connecting.
     if (!device.paired) {
-      // Set the pairing device and clear any pairing event.
       this.pairingDevice_ = device;
-      this.pairingEvent_ = null;
-
       this.openDialog_('pairDevice');
     }
 
     this.bluetoothPrivate.connect(device.address, function(result) {
       var error;
       if (chrome.runtime.lastError) {
         error = chrome.runtime.lastError.message;
       } else {
         switch (result) {
           case chrome.bluetoothPrivate.ConnectResultType.ALREADY_CONNECTED:
           case chrome.bluetoothPrivate.ConnectResultType.AUTH_CANCELED:
           case chrome.bluetoothPrivate.ConnectResultType.IN_PROGRESS:
           case chrome.bluetoothPrivate.ConnectResultType.SUCCESS:
             break;
           default:
             error = result;
         }
       }
 
       if (!error) {
         this.$$('#deviceDialog').close();
         return;
       }
 
-      var name = this.getDeviceName_(device);
+      var name = device.name || device.address;
       var id = 'bluetooth_connect_' + error;
       if (this.i18nExists(id)) {
         this.errorMessage_ = this.i18n(id, name);
       } else {
         this.errorMessage_ = error;
         console.error('Unexpected error connecting to: ' + name + ': ' + error);
       }
       this.openDialog_('connectError');
     }.bind(this));
   },
@@ skipping 22 matching lines @@
         console.error(
             'Error forgetting: ' + device.name + ': ' +
             chrome.runtime.lastError.message);
       }
       this.updateDeviceList_();
     }.bind(this));
   },
 
   /**
    * @param {string} dialogId
-   * @param {string} dialogToShow The name of the dialog.
-   * @return {boolean}
-   * @private
-   */
-  dialogIsVisible_: function(dialogId, dialogToShow) {
-    return dialogToShow == dialogId;
-  },
-
-  /**
-   * @param {string} dialogId
    * @private
    */
   openDialog_: function(dialogId) {
     if (this.dialogId_) {
       // Dialog already opened, just update the contents.
       this.dialogId_ = dialogId;
       return;
     }
     this.dialogId_ = dialogId;
     // Call flush so that the dialog gets sized correctly before it is opened.
     Polymer.dom.flush();
     var dialog = this.$$('#deviceDialog');
     dialog.open();
     this.startDiscovery_();
   },
 
   /** @private */
   onDialogClosed_: function() {
     this.stopDiscovery_();
     this.dialogId_ = '';
-    this.pairingDevice_ = null;
-    this.pairingEvent_ = null;
-  },
-
-  /**
-   * @param {Event} e
-   * @private
-   */
-  stopTap_: function(e) {
-    e.stopPropagation();
+    this.pairingDevice_ = undefined;
   },
 });