// 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.
#ifndef CHROME_BROWSER_UI_WEBUI_OPTIONS_CHROMEOS_BLUETOOTH_OPTIONS_HANDLER_H_
#define CHROME_BROWSER_UI_WEBUI_OPTIONS_CHROMEOS_BLUETOOTH_OPTIONS_HANDLER_H_
#include <string>
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "chrome/browser/ui/webui/options/options_ui.h"
#include "device/bluetooth/bluetooth_adapter.h"
#include "device/bluetooth/bluetooth_device.h"
#include "device/bluetooth/bluetooth_discovery_session.h"
namespace base {
class DictionaryValue;
}
namespace chromeos {
namespace options {
// Handler for Bluetooth options on the system options page.
class BluetoothOptionsHandler
: public ::options::OptionsPageUIHandler,
public device::BluetoothAdapter::Observer,
public device::BluetoothDevice::PairingDelegate {
public:
BluetoothOptionsHandler();
virtual ~BluetoothOptionsHandler();
// OptionsPageUIHandler implementation.
virtual void GetLocalizedValues(
base::DictionaryValue* localized_strings) OVERRIDE;
virtual void RegisterMessages() OVERRIDE;
virtual void InitializeHandler() OVERRIDE;
virtual void InitializePage() OVERRIDE;
void InitializeAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
// Sends a notification to the Web UI of the status of a Bluetooth device.
// |device| is the Bluetooth device.
// |params| is an optional set of parameters.
void SendDeviceNotification(const device::BluetoothDevice* device,
base::DictionaryValue* params);
// device::BluetoothDevice::PairingDelegate override.
//
// This method will be called when the Bluetooth daemon requires a
// PIN Code for authentication of the device |device|, the UI will display
// a blank entry form to obtain the PIN code from the user.
//
// PIN Codes are generally required for Bluetooth 2.0 and earlier devices
// for which there is no automatic pairing or special handling.
virtual void RequestPinCode(device::BluetoothDevice* device) OVERRIDE;
// device::BluetoothDevice::PairingDelegate override.
//
// This method will be called when the Bluetooth daemon requires a
// Passkey for authentication of the device |device|, the UI will display
// a blank entry form to obtain the passkey from the user (a numeric in the
// range 0-999999).
//
// Passkeys are generally required for Bluetooth 2.1 and later devices
// which cannot provide input or display on their own, and don't accept
// passkey-less pairing.
virtual void RequestPasskey(device::BluetoothDevice* device) OVERRIDE;
// device::BluetoothDevice::PairingDelegate override.
//
// This method will be called when the Bluetooth daemon requires that the
// user enter the PIN code |pincode| into the device |device| so that it
// may be authenticated, the UI will display the PIN code with accompanying
// instructions.
//
// This is used for Bluetooth 2.0 and earlier keyboard devices, the
// |pincode| will always be a six-digit numeric in the range 000000-999999
// for compatibilty with later specifications.
virtual void DisplayPinCode(device::BluetoothDevice* device,
const std::string& pincode) OVERRIDE;
// device::BluetoothDevice::PairingDelegate override.
//
// This method will be called when the Bluetooth daemon requires that the
// user enter the Passkey |passkey| into the device |device| so that it
// may be authenticated, the UI will display the passkey with accompanying
// instructions.
//
// This is used for Bluetooth 2.1 and later devices that support input
// but not display, such as keyboards. The Passkey is a numeric in the
// range 0-999999 and should be always presented zero-padded to six
// digits.
virtual void DisplayPasskey(
device::BluetoothDevice* device, uint32 passkey) OVERRIDE;
// device::BluetoothDevice::PairingDelegate override.
//
// This method will be called when the Bluetooth daemon gets a notification
// of a key entered on the device |device| while pairing with the device
// using a PIN code or a Passkey.
//
// The UI will show a visual indication that a given key was pressed in the
// same pairing overlay where the PIN code or Passkey is displayed.
//
// A first call with |entered| as 0 will indicate that this notification
// mechanism is supported by the device allowing the UI to display this fact.
// A last call with |entered| as the length of the key plus one will indicate
// that the [enter] key was pressed.
virtual void KeysEntered(device::BluetoothDevice* device,
uint32 entered) OVERRIDE;
// device::BluetoothDevice::PairingDelegate override.
//
// This method will be called when the Bluetooth daemon requires that the
// user confirm that the Passkey |passkey| is displayed on the screen
// of the device |device| so that it may be authenticated, the UI will
// display the passkey with accompanying instructions.
//
// This is used for Bluetooth 2.1 and later devices that support display,
// such as other computers or phones. The Passkey is a numeric in the
// range 0-999999 and should be always present zero-padded to six
// digits.
virtual void ConfirmPasskey(
device::BluetoothDevice* device, uint32 passkey) OVERRIDE;
// device::BluetoothDevice::PairingDelegate override.
virtual void AuthorizePairing(device::BluetoothDevice* device) OVERRIDE;
// Displays a Bluetooth error.
// |error| maps to a localized resource for the error message.
// |address| is the address of the Bluetooth device. May be an empty
// string if the error is not specific to a single device.
void ReportError(const std::string& error, const std::string& address);
// device::BluetoothAdapter::Observer implementation.
virtual void AdapterPresentChanged(device::BluetoothAdapter* adapter,
bool present) OVERRIDE;
virtual void AdapterPoweredChanged(device::BluetoothAdapter* adapter,
bool powered) OVERRIDE;
virtual void AdapterDiscoveringChanged(device::BluetoothAdapter* adapter,
bool discovering) OVERRIDE;
virtual void DeviceAdded(device::BluetoothAdapter* adapter,
device::BluetoothDevice* device) OVERRIDE;
virtual void DeviceChanged(device::BluetoothAdapter* adapter,
device::BluetoothDevice* device) OVERRIDE;
virtual void DeviceRemoved(device::BluetoothAdapter* adapter,
device::BluetoothDevice* device) OVERRIDE;
private:
// Displays in the UI a connecting to the device |device| message.
void DeviceConnecting(device::BluetoothDevice* device);
// Called by device::BluetoothAdapter in response to a failure to
// change the power status of the adapter.
void EnableChangeError();
// Called by device::BluetoothAdapter in response to a successful request
// to initiate a discovery session.
void OnStartDiscoverySession(
scoped_ptr<device::BluetoothDiscoverySession> discovery_session);
// Called by device::BluetoothAdapter in response to a failure to
// initiate a discovery session.
void FindDevicesError();
// Called by device::BluetoothAdapter in response to a failure to
// terminate a discovery session.
void StopDiscoveryError();
// Called by device::BluetoothDevice on a successful pairing and connection
// to a device.
void Connected();
// Called by device::BluetoothDevice in response to a failure to
// connect to the device with bluetooth address |address| due to an error
// encoded in |error_code|.
void ConnectError(const std::string& address,
device::BluetoothDevice::ConnectErrorCode error_code);
// Called by device::BluetoothDevice in response to a failure to
// disconnect the device with bluetooth address |address|.
void DisconnectError(const std::string& address);
// Called by device::BluetoothDevice in response to a failure to
// disconnect and unpair the device with bluetooth address |address|.
void ForgetError(const std::string& address);
// Called when the 'Enable bluetooth' checkbox value is changed.
// |args| will contain the checkbox checked state as a string
// ("true" or "false").
void EnableChangeCallback(const base::ListValue* args);
// Called when the 'Find Devices' button is pressed from the Bluetooth
// ssettings.
// |args| will be an empty list.
void FindDevicesCallback(const base::ListValue* args);
// Called when the user requests to connect to or disconnect from a Bluetooth
// device.
// |args| will be a list containing two or three arguments, the first argument
// is the device ID and the second is the requested action. If a third
// argument is present, it is the passkey for pairing confirmation.
void UpdateDeviceCallback(const base::ListValue* args);
// Called when the "Add a device" dialog closes to stop the discovery
// process.
// |args| will be an empty list.
void StopDiscoveryCallback(const base::ListValue* args);
// Called when the list of paired devices is initialized in order to
// populate the list.
// |args| will be an empty list.
void GetPairedDevicesCallback(const base::ListValue* args);
// Default bluetooth adapter, used for all operations.
scoped_refptr<device::BluetoothAdapter> adapter_;
// True, if the UI has requested device discovery. False, if either no device
// discovery was requested or the dialog responsible for device discovery was
// dismissed.
bool should_run_device_discovery_;
// The current device discovery session. Only one active discovery session is
// kept at a time and the instance that |discovery_session_| points to gets
// replaced by a new one when a new discovery session is initiated.
scoped_ptr<device::BluetoothDiscoverySession> discovery_session_;
// Cached information about the current pairing device, if any.
std::string pairing_device_address_;
std::string pairing_device_pairing_;
std::string pairing_device_pincode_;
int pairing_device_passkey_;
int pairing_device_entered_;
// Weak pointer factory for generating 'this' pointers that might live longer
// than this object does.
base::WeakPtrFactory<BluetoothOptionsHandler> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(BluetoothOptionsHandler);
};
} // namespace options
} // namespace chromeos
#endif // CHROME_BROWSER_UI_WEBUI_OPTIONS_CHROMEOS_BLUETOOTH_OPTIONS_HANDLER_H_