MD Settings: Bluetooth: Additional polish

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

 // Copyright 2016 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.exportPath('settings');
 
 (function() {
 
 var PairingEventType = chrome.bluetoothPrivate.PairingEventType;
 
@@ skipping 28 matching lines @@
   adapterStateChanged_: function() {
     if (!this.adapterState.powered)
       this.fire('close-dialog');
   },
 
   /**
    * @param {!chrome.bluetooth.Device} device
    * @return {boolean}
    * @private
    */
-  deviceNotPaired_: function(device) {
-    return !device.paired;
-  },
+  deviceNotPaired_: function(device) { return !device.paired; },
 
   /**
    * @param {!Array<!chrome.bluetooth.Device>} deviceList
    * @return {boolean} True if deviceList contains any unpaired devices.
    * @private
    */
   haveDevices_: function(deviceList) {
     return this.deviceList.findIndex(function(d) { return !d.paired; }) != -1;
   },
 
   /**
    * @param {!{detail: {action: string, device: !chrome.bluetooth.Device}}} e
    * @private
    */
   onDeviceEvent_: function(e) {
     this.fire('device-event', e.detail);
-    /** @type {Event} */(e).stopPropagation();
+    /** @type {Event} */ (e).stopPropagation();
   },
 };
 
 /** @polymerBehavior */
 settings.BluetoothPairDeviceBehavior = {
   properties: {
     /**
      * Current Pairing device.
      * @type {?chrome.bluetooth.Device|undefined}
      */
     pairingDevice: Object,
 
     /**
      * Current Pairing event.
      * @type {?chrome.bluetoothPrivate.PairingEvent|undefined}
      */
     pairingEvent: Object,
 
+    /** Pincode or passkey value, used to trigger connect enabled changes. */
+    pinOrPass: String,
+
     /**
      * @const
      * @type {!Array<number>}
      */
     digits: {
       type: Array,
       readOnly: true,
       value: [0, 1, 2, 3, 4, 5],
     },
   },
 
   observers: [
     'pairingChanged_(pairingDevice, pairingEvent)',
   ],
 
   /**
    * @param {?chrome.bluetooth.Device} pairingDevice
    * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @private
    */
   pairingChanged_: function(pairingDevice, pairingEvent) {
     // Auto-close the dialog when pairing completes.
     if (pairingDevice && pairingDevice.connected) {
       this.fire('close-dialog', '');
       return;
     }
+    this.pinOrPass = '';
   },
 
   /**
    * @param {?chrome.bluetooth.Device} device
    * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {string}
    * @private
    */
   getMessage_: function(device, pairingEvent) {
     if (!device)
@@ skipping 54 matching lines @@
 
   /**
    * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {boolean}
    * @private
    */
   showConnect_: function(pairingEvent) {
     if (!pairingEvent)
       return false;
     var pairing = pairingEvent.pairing;
-    if (pairing == PairingEventType.REQUEST_PINCODE) {
-      var pincode = /** @type {{invalid: boolean}} */(this.$.pincode);
-      return !pincode.invalid;
-    } else if (pairing == PairingEventType.REQUEST_PASSKEY) {
-      var passkey = /** @type {{invalid: boolean}} */(this.$.passkey);
-      return !passkey.invalid;
-    }
-    return false;
+    return pairing == PairingEventType.REQUEST_PINCODE ||
+        pairing == PairingEventType.REQUEST_PASSKEY;
   },
 
   /**
+   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
+   * @param {string} pinOrPass Unused; call is triggered when this changes.
+   * @return {boolean}
+   * @private
+   */
+  enableConnect_: function(pairingEvent, pinOrPass) {
+    if (!this.showConnect_(this.pairingEvent))
+      return false;
+    var inputId =
+        (this.pairingEvent.pairing == PairingEventType.REQUEST_PINCODE) ?
+        '#pincode' :
+        '#passkey';
+    var paperInput = /** @type {!PaperInputElement} */ (this.$$(inputId));
+    assert(paperInput);
+    /** @type {string} */ var value = paperInput.value;
+    return !!value && paperInput.validate();
+  },
+
+  /**
    * @param {?chrome.bluetooth.Device} device
    * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {boolean}
    * @private
    */
   showDismiss_: function(device, pairingEvent) {
     return (!!device && device.paired) ||
         (!!pairingEvent && pairingEvent.pairing == PairingEventType.COMPLETE);
   },
 
@@ skipping 20 matching lines @@
     if (!this.pairingDevice)
       return;
     var options =
         /** @type {!chrome.bluetoothPrivate.SetPairingResponseOptions} */ {
           device: this.pairingDevice,
           response: response
         };
     if (response == chrome.bluetoothPrivate.PairingResponse.CONFIRM) {
       var pairing = this.pairingEvent.pairing;
       if (pairing == PairingEventType.REQUEST_PINCODE)
-        options.pincode = this.$.pincode.value;
+        options.pincode = this.$$('#pincode').value;
       else if (pairing == PairingEventType.REQUEST_PASSKEY)
-        options.passkey = parseInt(this.$.passkey.value, 10);
+        options.passkey = parseInt(this.$$('#passkey').value, 10);
     }
     this.fire('response', options);
   },
 
   /**
    * @param {!PairingEventType} eventType
    * @return {string}
    * @private
    */
   getEventDesc_: function(eventType) {
     assert(eventType);
     if (eventType == PairingEventType.COMPLETE ||
         eventType == PairingEventType.KEYS_ENTERED ||
         eventType == PairingEventType.REQUEST_AUTHORIZATION) {
       return 'bluetoothStartConnecting';
     }
-    return 'bluetooth_' + /** @type {string} */(eventType);
+    return 'bluetooth_' + /** @type {string} */ (eventType);
   },
 
   /**
    * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @param {number} index
    * @return {string}
    * @private
    */
   getPinDigit_: function(pairingEvent, index) {
     if (!pairingEvent)
       return '';
     var digit = '0';
     var pairing = pairingEvent.pairing;
     if (pairing == PairingEventType.DISPLAY_PINCODE && pairingEvent.pincode &&
         index < pairingEvent.pincode.length) {
       digit = pairingEvent.pincode[index];
-    } else if (pairingEvent.passkey &&
-               (pairing == PairingEventType.DISPLAY_PASSKEY ||
-                pairing == PairingEventType.KEYS_ENTERED ||
-                pairing == PairingEventType.CONFIRM_PASSKEY)) {
+    } else if (
+        pairingEvent.passkey && (pairing == PairingEventType.DISPLAY_PASSKEY ||
+                                 pairing == PairingEventType.KEYS_ENTERED ||
+                                 pairing == PairingEventType.CONFIRM_PASSKEY)) {
       var passkeyString = String(pairingEvent.passkey);
       if (index < passkeyString.length)
         digit = passkeyString[index];
     }
     return digit;
   },
 
   /**
    * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @param {number} index
    * @return {string}
    * @private
    */
   getPinClass_: function(pairingEvent, index) {
     if (!pairingEvent)
       return '';
     if (pairingEvent.pairing == PairingEventType.CONFIRM_PASSKEY)
       return 'confirm';
     var cssClass = 'display';
     if (pairingEvent.pairing == PairingEventType.DISPLAY_PASSKEY) {
       if (index == 0)
         cssClass += ' next';
       else
         cssClass += ' untyped';
     } else if (
         pairingEvent.pairing == PairingEventType.KEYS_ENTERED &&
         pairingEvent.enteredKey) {
       var enteredKey = pairingEvent.enteredKey;  // 1-7
-      var lastKey = this.digits.length;  // 6
+      var lastKey = this.digits.length;          // 6
       if ((index == -1 && enteredKey > lastKey) || (index + 1 == enteredKey))
         cssClass += ' next';
       else if (index > enteredKey)
         cssClass += ' untyped';
     }
     return cssClass;
   },
 };
 
 Polymer({
   is: 'bluetooth-device-dialog',
 
   behaviors: [
     I18nBehavior,
     settings.BluetoothAddDeviceBehavior,
     settings.BluetoothPairDeviceBehavior,
   ],
 
   properties: {
     /** Which version of this dialog to show (adding or pairing). */
-    dialogType: String,
+    dialogId: String,
   },
 
+  open: function() {
+    this.pinOrPass = '';
+    this.$.dialog.open();
+  },
+
+  close: function() { this.$.dialog.close(); },
+
   /** @private */
-  deviceListChanged_: function(e) {
-    this.$.dialog.notifyResize();
+  deviceListChanged_: function(e) { this.$.dialog.notifyResize(); },
+
+  /**
+   * @param {string} dialogId
+   * @return {string} The title of for that |dialogId|.
+   */
+  getTitle_: function(dialogId) {
+    return this.i18n(
+        dialogId == 'addDevice' ? 'bluetoothAddDevicePageTitle' :
+                                  'bluetoothPairDevicePageTitle');
   },
 
   /**
-   * @param {string} dialogType
-   * @return {string} The title of for that |dialogType|.
-   */
-  getTitle_: function(dialogType) {
-    return this.i18n(dialogType == 'addDevice' ?
-        'bluetoothAddDevicePageTitle' : 'bluetoothPairDevicePageTitle');
-  },
-
-  /**
    * @param {string} currentDialogType
    * @param {string} wantedDialogType
    * @return {boolean}
    * @private
    */
   isDialogType_: function(currentDialogType, wantedDialogType) {
     return currentDialogType == wantedDialogType;
   },
 
   /** @private */
   onCancelTap_: function() {
     // NOTE: tapping on an element with [dialog-dismiss] doesn't trigger an
     // iron-overlay-cancel event, whereas tapping (X) or pressing Esc does.
     // Using cancel() ensures all 3 ways to close the dialog run the same code.
     this.$.dialog.cancel();
   },
 
   /** @private */
   onIronOverlayCanceled_: function() {
-    if (this.dialogType == 'pairDevice')
+    if (this.dialogId == 'pairDevice')
       this.sendResponse_(chrome.bluetoothPrivate.PairingResponse.CANCEL);
   },
 
   /** @private */
-  onIronOverlayClosed_: function() {
-    this.fire('close-dialog', '');
-  },
-
-  open: function() {
-    this.$.dialog.open();
-  },
-
-  close: function() {
-    this.$.dialog.close();
-  },
+  onIronOverlayClosed_: function() { this.fire('close-dialog', ''); },
 });
 
 })();