MD Settings: Bluetooth 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 11 matching lines @@
       type: Object,
       observer: 'adapterStateChanged_',
     },
 
     /**
      * The ordered list of bluetooth devices.
      * @type {!Array<!chrome.bluetooth.Device>}
      */
     deviceList: {
       type: Array,
-      value: /** @return {Array} */ function() { return []; },
+      value: /** @return {Array} */ function() {
+        return [];
+      },
     },
   },
 
   /** @private */
   adapterStateChanged_: function() {
     if (!this.adapterState.powered)
       this.close();
   },
 
   /**
    * @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;
+    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();
   },
@@ skipping 25 matching lines @@
       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) {
+  /** @private */
+  pairingChanged_: function() {
     // Auto-close the dialog when pairing completes.
-    if (pairingDevice && pairingDevice.connected) {
+    if (this.pairingDevice && this.pairingDevice.connected) {
       this.close();
       return;
     }
     this.pinOrPass = '';
   },
 
   /**
-   * @param {?chrome.bluetooth.Device} device
-   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {string}
    * @private
    */
-  getMessage_: function(device, pairingEvent) {
-    if (!device)
+  getMessage_: function() {
+    if (!this.pairingDevice)
       return '';
     var message;
-    if (!pairingEvent)
+    if (!this.pairingEvent)
       message = 'bluetoothStartConnecting';
     else
-      message = this.getEventDesc_(pairingEvent.pairing);
-    return this.i18n(message, device.name);
+      message = this.getEventDesc_(this.pairingEvent.pairing);
+    return this.i18n(message, this.pairingDevice.name);
   },
 
   /**
-   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {boolean}
    * @private
    */
-  showEnterPincode_: function(pairingEvent) {
-    return !!pairingEvent &&
-        pairingEvent.pairing == PairingEventType.REQUEST_PINCODE;
+  showEnterPincode_: function() {
+    return !!this.pairingEvent &&
+        this.pairingEvent.pairing == PairingEventType.REQUEST_PINCODE;
   },
 
   /**
-   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {boolean}
    * @private
    */
-  showEnterPasskey_: function(pairingEvent) {
-    return !!pairingEvent &&
-        pairingEvent.pairing == PairingEventType.REQUEST_PASSKEY;
+  showEnterPasskey_: function() {
+    return !!this.pairingEvent &&
+        this.pairingEvent.pairing == PairingEventType.REQUEST_PASSKEY;
   },
 
   /**
-   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {boolean}
    * @private
    */
-  showDisplayPassOrPin_: function(pairingEvent) {
-    if (!pairingEvent)
+  showDisplayPassOrPin_: function() {
+    if (!this.pairingEvent)
       return false;
-    var pairing = pairingEvent.pairing;
+    var pairing = this.pairingEvent.pairing;
     return (
         pairing == PairingEventType.DISPLAY_PINCODE ||
         pairing == PairingEventType.DISPLAY_PASSKEY ||
         pairing == PairingEventType.CONFIRM_PASSKEY ||
         pairing == PairingEventType.KEYS_ENTERED);
   },
 
   /**
-   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {boolean}
    * @private
    */
-  showAcceptReject_: function(pairingEvent) {
-    return !!pairingEvent &&
-        pairingEvent.pairing == PairingEventType.CONFIRM_PASSKEY;
+  showAcceptReject_: function() {
+    return !!this.pairingEvent &&
+        this.pairingEvent.pairing == PairingEventType.CONFIRM_PASSKEY;
   },
 
   /**
-   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @return {boolean}
    * @private
    */
-  showConnect_: function(pairingEvent) {
-    if (!pairingEvent)
+  showConnect_: function() {
+    if (!this.pairingEvent)
       return false;
-    var pairing = pairingEvent.pairing;
+    var pairing = this.pairingEvent.pairing;
     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))
+  enableConnect_: function() {
+    if (!this.showConnect_())
       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);
+  showDismiss_: function() {
+    return (!!this.paringDevice && this.pairingDevice.paired) ||
+        (!!this.pairingEvent &&
+         this.pairingEvent.pairing == PairingEventType.COMPLETE);
   },
 
   /** @private */
   onAcceptTap_: function() {
     this.sendResponse_(chrome.bluetoothPrivate.PairingResponse.CONFIRM);
   },
 
   /** @private */
   onConnectTap_: function() {
     this.sendResponse_(chrome.bluetoothPrivate.PairingResponse.CONFIRM);
   },
 
   /** @private */
   onRejectTap_: function() {
     this.sendResponse_(chrome.bluetoothPrivate.PairingResponse.REJECT);
   },
 
-  /** @private */
+  /**
+   * @param {!chrome.bluetoothPrivate.PairingResponse} response
+   * @private
+   */
   sendResponse_: function(response) {
     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;
@@ skipping 14 matching lines @@
     assert(eventType);
     if (eventType == PairingEventType.COMPLETE ||
         eventType == PairingEventType.KEYS_ENTERED ||
         eventType == PairingEventType.REQUEST_AUTHORIZATION) {
       return 'bluetoothStartConnecting';
     }
     return 'bluetooth_' + /** @type {string} */ (eventType);
   },
 
   /**
-   * @param {?chrome.bluetoothPrivate.PairingEvent} pairingEvent
    * @param {number} index
    * @return {string}
    * @private
    */
-  getPinDigit_: function(pairingEvent, index) {
-    if (!pairingEvent)
+  getPinDigit_: function(index) {
+    if (!this.pairingEvent)
       return '';
     var digit = '0';
-    var pairing = pairingEvent.pairing;
-    if (pairing == PairingEventType.DISPLAY_PINCODE && pairingEvent.pincode &&
-        index < pairingEvent.pincode.length) {
-      digit = pairingEvent.pincode[index];
+    var pairing = this.pairingEvent.pairing;
+    if (pairing == PairingEventType.DISPLAY_PINCODE &&
+        this.pairingEvent.pincode && index < this.pairingEvent.pincode.length) {
+      digit = this.pairingEvent.pincode[index];
     } else if (
-        pairingEvent.passkey && (pairing == PairingEventType.DISPLAY_PASSKEY ||
-                                 pairing == PairingEventType.KEYS_ENTERED ||
-                                 pairing == PairingEventType.CONFIRM_PASSKEY)) {
-      var passkeyString = String(pairingEvent.passkey);
+        this.pairingEvent.passkey &&
+        (pairing == PairingEventType.DISPLAY_PASSKEY ||
+         pairing == PairingEventType.KEYS_ENTERED ||
+         pairing == PairingEventType.CONFIRM_PASSKEY)) {
+      var passkeyString = String(this.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)
+  getPinClass_: function(index) {
+    if (!this.pairingEvent)
       return '';
-    if (pairingEvent.pairing == PairingEventType.CONFIRM_PASSKEY)
+    if (this.pairingEvent.pairing == PairingEventType.CONFIRM_PASSKEY)
       return 'confirm';
     var cssClass = 'display';
-    if (pairingEvent.pairing == PairingEventType.DISPLAY_PASSKEY) {
+    if (this.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
+        this.pairingEvent.pairing == PairingEventType.KEYS_ENTERED &&
+        this.pairingEvent.enteredKey) {
+      var enteredKey = this.pairingEvent.enteredKey;  // 1-7
+      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). */
     dialogId: String,
   },
 
+  observers: [
+    'dialogUpdated_(dialogId, pairingEvent)',
+  ],
+
   open: function() {
     this.pinOrPass = '';
     this.getDialog_().showModal();
   },
 
   close: function() {
     var dialog = this.getDialog_();
     if (dialog.open)
       dialog.close();
   },
 
+  /** @private */
+  dialogUpdated_: function() {
+    if (this.showEnterPincode_())
+      this.$$('#pincode').focus();
+    else if (this.showEnterPasskey_())
+      this.$$('#passkey').focus();
+  },
+
   /**
    * @return {!CrDialogElement}
    * @private
    */
   getDialog_: function() {
     return /** @type {!CrDialogElement} */ (this.$.dialog);
   },
 
   /**
    * @param {string} dialogId
    * @return {string} The title of for that |dialogId|.
    */
   getTitle_: function(dialogId) {
     if (dialogId == 'addDevice')
       return this.i18n('bluetoothAddDevicePageTitle');
     // Use the 'pair' title for the pairing dialog and error dialog.
     return this.i18n('bluetoothPairDevicePageTitle');
   },
 
   /**
-   * @param {string} currentDialogType
-   * @param {string} wantedDialogType
+   * @param {string} desiredDialogType
    * @return {boolean}
    * @private
    */
-  isDialogType_: function(currentDialogType, wantedDialogType) {
-    return currentDialogType == wantedDialogType;
+  isDialogType_: function(desiredDialogType, currentDialogType) {
+    return currentDialogType == desiredDialogType;
   },
 
   /** @private */
   onCancelTap_: function() {
     this.getDialog_().cancel();
   },
 
   /** @private */
   onDialogCanceled_: function() {
     if (this.dialogId == 'pairDevice')
       this.sendResponse_(chrome.bluetoothPrivate.PairingResponse.CANCEL);
   },
 });
 
 })();