bluetooth: implement device pairing support

chrome/browser/ui/webui/options2/chromeos/bluetooth_options_handler2.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/ui/webui/options2/chromeos/bluetooth_options_handler2.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
 #include "chrome/browser/chromeos/system/runtime_environment.h"
 #include "chrome/browser/ui/webui/options2/chromeos/system_settings_provider2.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // |UpdateDeviceCallback| takes a variable length list as an argument. The
 // value stored in each list element is indicated by the following constants.
 const int kUpdateDeviceAddressIndex = 0;
 const int kUpdateDeviceCommandIndex = 1;
 const int kUpdateDevicePasskeyIndex = 2;
 
+// |UpdateDeviceCallback| provides a command value of one of the following
+// constants that indicates what update it is providing to us.
+const std::string kConnectCommand = "connect";
+const std::string kCancelCommand = "cancel";
+const std::string kAcceptCommand = "accept";
+const std::string kRejectCommand = "reject";
+const std::string kDisconnectCommand = "disconnect";
+const std::string kForgetCommand = "forget";
+
+// |SendDeviceNotification| may include a pairing parameter whose value
+// is one of the following constants instructing the UI to perform a certain
+// action.
+const std::string kEnterPinCode = "bluetoothEnterPinCode";
+const std::string kEnterPasskey = "bluetoothEnterPasskey";
+const std::string kRemotePinCode = "bluetoothRemotePinCode";
+const std::string kRemotePasskey = "bluetoothRemotePasskey";
+const std::string kConfirmPasskey = "bluetoothConfirmPasskey";
+
 }  // namespace
 
 namespace chromeos {
 namespace options2 {
 
-BluetoothOptionsHandler::BluetoothOptionsHandler() {
+BluetoothOptionsHandler::BluetoothOptionsHandler() : weak_ptr_factory_(this) {
 }
 
 BluetoothOptionsHandler::~BluetoothOptionsHandler() {
   if (!CommandLine::ForCurrentProcess()
       ->HasSwitch(switches::kEnableBluetooth)) {
     return;
   }
 
   adapter_->RemoveObserver(this);
 }
@@ skipping 137 matching lines @@
   AdapterPresentChanged(adapter_.get(), adapter_->IsPresent());
 }
 
 void BluetoothOptionsHandler::EnableChangeCallback(
     const ListValue* args) {
   bool bluetooth_enabled;
   args->GetBoolean(0, &bluetooth_enabled);
 
   adapter_->SetPowered(bluetooth_enabled,
                        base::Bind(&BluetoothOptionsHandler::ErrorCallback,
-                                  base::Unretained(this)));
+                                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothOptionsHandler::FindDevicesCallback(
     const ListValue* args) {
   adapter_->SetDiscovering(true,
                            base::Bind(&BluetoothOptionsHandler::ErrorCallback,
-                                      base::Unretained(this)));
+                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothOptionsHandler::UpdateDeviceCallback(
     const ListValue* args) {
-  // TODO(kevers): Trigger connect/disconnect.
-  int size = args->GetSize();
   std::string address;
+  args->GetString(kUpdateDeviceAddressIndex, &address);
+
+  BluetoothDevice* device = adapter_->GetDevice(address);
+  if (!device)
+    return;
+
   std::string command;
-  args->GetString(kUpdateDeviceAddressIndex, &address);
   args->GetString(kUpdateDeviceCommandIndex, &command);
-  if (size > kUpdateDevicePasskeyIndex) {
-    // Passkey confirmation as part of the pairing process.
-    std::string passkey;
-    args->GetString(kUpdateDevicePasskeyIndex, &passkey);
-    DVLOG(1) << "UpdateDeviceCallback: " << address << ": " << command
-            << " [" << passkey << "]";
+
+  if (command == kConnectCommand) {
+    int size = args->GetSize();
+    if (size > kUpdateDevicePasskeyIndex) {
+      // PIN code or Passkey entry during the pairing process.
+      // TODO(keybuk, kevers): disambiguate PIN (string) vs. Passkey (integer)
+      std::string pincode;
+      args->GetString(kUpdateDevicePasskeyIndex, &pincode);
+      DVLOG(1) << "PIN code supplied: " << address << ": " << pincode;
+
+      device->SetPinCode(pincode);
+
+    } else {
+      // Connection request.
+      DVLOG(1) << "Connect: " << address;
+      if (device->WasDiscovered()) {
+        device->PairAndConnect(
+            this, base::Bind(&BluetoothOptionsHandler::ErrorCallback,
+                             weak_ptr_factory_.GetWeakPtr()));
+      } else {
+        device->Connect(base::Bind(&BluetoothOptionsHandler::ErrorCallback,
+                                   weak_ptr_factory_.GetWeakPtr()));
+      }
+    }
+

[James Hawkins, 2012/03/13 23:12:45]

nit: Remove blank line. Here and elsewhere at the end of all these blocks.

[keybuk, 2012/03/14 00:15:26]

Done.

+  } else if (command == kCancelCommand) {
+    // Cancel pairing.
+    DVLOG(1) << "Cancel pairing: " << address;
+    device->CancelPairing();
+
+  } else if (command == kAcceptCommand) {
+    // Confirm displayed Passkey.
+    DVLOG(1) << "Confirm pairing: " << address;
+    device->ConfirmPairing();
+
+  } else if (command == kRejectCommand) {
+    // Reject displayed Passkey.
+    DVLOG(1) << "Reject pairing: " << address;
+    device->RejectPairing();
+
+  } else if (command == kDisconnectCommand) {
+    // TODO(keybuk): implement
+    DVLOG(1) << "Disconnect device: " << address;
+
+  } else if (command == kForgetCommand) {
+    // TODO(keybuk): implement
+    DVLOG(1) << "Forget device: " << address;
+
   } else {
-    // Initiating a device connection or disconnecting
-    DVLOG(1) << "UpdateDeviceCallback: " << address << ": " << command;
+    LOG(WARNING) << "Unknown updateBluetoothDevice command: " << command;
   }
 }
 
 void BluetoothOptionsHandler::StopDiscoveryCallback(
     const ListValue* args) {
   adapter_->SetDiscovering(false,
                            base::Bind(&BluetoothOptionsHandler::ErrorCallback,
-                                      base::Unretained(this)));
+                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothOptionsHandler::GetPairedDevicesCallback(
     const ListValue* args) {
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
 
   for (BluetoothAdapter::DeviceList::iterator iter = devices.begin();
        iter != devices.end(); ++iter)
     SendDeviceNotification(*iter, NULL);
 }
 
 void BluetoothOptionsHandler::SendDeviceNotification(
     const BluetoothDevice* device,
     base::DictionaryValue* params) {
   base::DictionaryValue js_properties;
   js_properties.SetString("name", device->GetName());
   js_properties.SetString("address", device->address());
   js_properties.SetBoolean("discovered", device->WasDiscovered());
   js_properties.SetBoolean("paired", device->IsPaired());
   js_properties.SetBoolean("connected", device->IsConnected());
   if (params) {
     js_properties.MergeDictionary(params);
   }
   web_ui()->CallJavascriptFunction(
       "options.BrowserOptions.addBluetoothDevice",
       js_properties);
 }
 
-void BluetoothOptionsHandler::DisplayPinCode(
-    const BluetoothDevice* device,
-    const std::string& pincode) {
+void BluetoothOptionsHandler::RequestPinCode(BluetoothDevice* device) {
   DictionaryValue params;
-  params.SetString("pairing", "bluetoothRemotePinCode");
+  params.SetString("pairing", kEnterPinCode);
+  SendDeviceNotification(device, &params);
+}
+
+void BluetoothOptionsHandler::RequestPasskey(BluetoothDevice* device) {
+  DictionaryValue params;
+  params.SetString("pairing", kEnterPasskey);
+  SendDeviceNotification(device, &params);
+}
+
+void BluetoothOptionsHandler::DisplayPinCode(BluetoothDevice* device,
+                                             const std::string& pincode) {
+  DictionaryValue params;
+  params.SetString("pairing", kRemotePinCode);
   params.SetString("pincode", pincode);
   SendDeviceNotification(device, &params);
 }
 
-void BluetoothOptionsHandler::DisplayPasskey(
-    const BluetoothDevice* device,
-    int passkey,
-    int entered) {
+void BluetoothOptionsHandler::DisplayPasskey(BluetoothDevice* device,
+                                             uint32 passkey) {
   DictionaryValue params;
-  params.SetString("pairing", "bluetoothRemotePasskey");
+  params.SetString("pairing", kRemotePasskey);
   params.SetInteger("passkey", passkey);
-  params.SetInteger("entered", entered);
   SendDeviceNotification(device, &params);
 }
 
-void BluetoothOptionsHandler::RequestPinCode(
-    const BluetoothDevice* device) {
+void BluetoothOptionsHandler::ConfirmPasskey(BluetoothDevice* device,
+                                             uint32 passkey) {
   DictionaryValue params;
-  params.SetString("pairing", "bluetoothEnterPinCode");
+  params.SetString("pairing", kConfirmPasskey);
+  params.SetInteger("passkey", passkey);
   SendDeviceNotification(device, &params);
 }
 
-void BluetoothOptionsHandler::RequestPasskey(
-    const BluetoothDevice* device) {
-  DictionaryValue params;
-  params.SetString("pairing", "bluetoothEnterPasskey");
-  SendDeviceNotification(device, &params);
-}
-
-void BluetoothOptionsHandler::RequestConfirmation(
-    const BluetoothDevice* device,
-    int passkey) {
-  DictionaryValue params;
-  params.SetString("pairing", "bluetoothConfirmPasskey");
-  params.SetInteger("passkey", passkey);
-  SendDeviceNotification(device, &params);
+void BluetoothOptionsHandler::DismissDisplayOrConfirm() {
+  // TODO(kevers): please fill this in
 }
 
 void BluetoothOptionsHandler::ReportError(
     const BluetoothDevice* device,
     ConnectionError error) {
+  // TODO(keybuk): not called from anywhere
   std::string errorCode;
   switch (error) {
   case DEVICE_NOT_FOUND:
     errorCode = "bluetoothErrorNoDevice";
     break;
   case INCORRECT_PIN:
     errorCode = "bluetoothErrorIncorrectPin";
     break;
   case CONNECTION_TIMEOUT:
     errorCode = "bluetoothErrorTimeout";
@@ skipping 35 matching lines @@
 void BluetoothOptionsHandler::ErrorCallback() {
   // TODO(keybuk): we don't get any form of error response from dbus::
   // yet, other than an error occurred. I'm going to fix that, then this
   // gets replaced by genuine error information from the method which we
   // can act on, rather than a debug log statement.
   DVLOG(1) << "Failed.";
 }
 
 }  // namespace options2
 }  // namespace chromeos