336 lines
8.8 KiB
C++
Executable File
336 lines
8.8 KiB
C++
Executable File
// Copyright (c) 2019 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.
|
|
|
|
// GENERATED FROM THE API DEFINITION IN
|
|
// extensions/common/api/bluetooth.idl
|
|
// DO NOT EDIT.
|
|
|
|
#ifndef EXTENSIONS_COMMON_API_BLUETOOTH_H__
|
|
#define EXTENSIONS_COMMON_API_BLUETOOTH_H__
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "base/logging.h"
|
|
#include "base/values.h"
|
|
|
|
namespace extensions {
|
|
namespace api {
|
|
namespace bluetooth {
|
|
|
|
//
|
|
// Types
|
|
//
|
|
|
|
// Allocation authorities for Vendor IDs.
|
|
enum VendorIdSource {
|
|
VENDOR_ID_SOURCE_NONE,
|
|
VENDOR_ID_SOURCE_BLUETOOTH,
|
|
VENDOR_ID_SOURCE_USB,
|
|
VENDOR_ID_SOURCE_LAST = VENDOR_ID_SOURCE_USB,
|
|
};
|
|
|
|
|
|
const char* ToString(VendorIdSource as_enum);
|
|
VendorIdSource ParseVendorIdSource(const std::string& as_string);
|
|
|
|
// Common device types recognized by Chrome.
|
|
enum DeviceType {
|
|
DEVICE_TYPE_NONE,
|
|
DEVICE_TYPE_COMPUTER,
|
|
DEVICE_TYPE_PHONE,
|
|
DEVICE_TYPE_MODEM,
|
|
DEVICE_TYPE_AUDIO,
|
|
DEVICE_TYPE_CARAUDIO,
|
|
DEVICE_TYPE_VIDEO,
|
|
DEVICE_TYPE_PERIPHERAL,
|
|
DEVICE_TYPE_JOYSTICK,
|
|
DEVICE_TYPE_GAMEPAD,
|
|
DEVICE_TYPE_KEYBOARD,
|
|
DEVICE_TYPE_MOUSE,
|
|
DEVICE_TYPE_TABLET,
|
|
DEVICE_TYPE_KEYBOARDMOUSECOMBO,
|
|
DEVICE_TYPE_LAST = DEVICE_TYPE_KEYBOARDMOUSECOMBO,
|
|
};
|
|
|
|
|
|
const char* ToString(DeviceType as_enum);
|
|
DeviceType ParseDeviceType(const std::string& as_string);
|
|
|
|
// Types for filtering bluetooth devices.
|
|
enum FilterType {
|
|
FILTER_TYPE_NONE,
|
|
FILTER_TYPE_ALL,
|
|
FILTER_TYPE_KNOWN,
|
|
FILTER_TYPE_LAST = FILTER_TYPE_KNOWN,
|
|
};
|
|
|
|
|
|
const char* ToString(FilterType as_enum);
|
|
FilterType ParseFilterType(const std::string& as_string);
|
|
|
|
struct AdapterState {
|
|
AdapterState();
|
|
~AdapterState();
|
|
AdapterState(AdapterState&& rhs);
|
|
AdapterState& operator=(AdapterState&& rhs);
|
|
|
|
// Populates a AdapterState object from a base::Value. Returns whether |out|
|
|
// was successfully populated.
|
|
static bool Populate(const base::Value& value, AdapterState* out);
|
|
|
|
// Creates a AdapterState object from a base::Value, or NULL on failure.
|
|
static std::unique_ptr<AdapterState> FromValue(const base::Value& value);
|
|
|
|
// Returns a new base::DictionaryValue representing the serialized form of
|
|
// this AdapterState object.
|
|
std::unique_ptr<base::DictionaryValue> ToValue() const;
|
|
|
|
// The address of the adapter, in the format 'XX:XX:XX:XX:XX:XX'.
|
|
std::string address;
|
|
|
|
// The human-readable name of the adapter.
|
|
std::string name;
|
|
|
|
// Indicates whether or not the adapter has power.
|
|
bool powered;
|
|
|
|
// Indicates whether or not the adapter is available (i.e. enabled).
|
|
bool available;
|
|
|
|
// Indicates whether or not the adapter is currently discovering.
|
|
bool discovering;
|
|
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(AdapterState);
|
|
};
|
|
|
|
struct Device {
|
|
Device();
|
|
~Device();
|
|
Device(Device&& rhs);
|
|
Device& operator=(Device&& rhs);
|
|
|
|
// Populates a Device object from a base::Value. Returns whether |out| was
|
|
// successfully populated.
|
|
static bool Populate(const base::Value& value, Device* out);
|
|
|
|
// Creates a Device object from a base::Value, or NULL on failure.
|
|
static std::unique_ptr<Device> FromValue(const base::Value& value);
|
|
|
|
// Returns a new base::DictionaryValue representing the serialized form of
|
|
// this Device object.
|
|
std::unique_ptr<base::DictionaryValue> ToValue() const;
|
|
|
|
// The address of the device, in the format 'XX:XX:XX:XX:XX:XX'.
|
|
std::string address;
|
|
|
|
// The human-readable name of the device.
|
|
std::unique_ptr<std::string> name;
|
|
|
|
// The class of the device, a bit-field defined by
|
|
// http://www.bluetooth.org/en-us/specification/assigned-numbers/baseband.
|
|
std::unique_ptr<int> device_class;
|
|
|
|
// The Device ID record of the device, where available.
|
|
VendorIdSource vendor_id_source;
|
|
|
|
std::unique_ptr<int> vendor_id;
|
|
|
|
std::unique_ptr<int> product_id;
|
|
|
|
std::unique_ptr<int> device_id;
|
|
|
|
// The type of the device, if recognized by Chrome. This is obtained from the
|
|
// |deviceClass| field and only represents a small fraction of the possible
|
|
// device types. When in doubt you should use the |deviceClass| field directly.
|
|
DeviceType type;
|
|
|
|
// Indicates whether or not the device is paired with the system.
|
|
std::unique_ptr<bool> paired;
|
|
|
|
// Indicates whether the device is currently connected to the system.
|
|
std::unique_ptr<bool> connected;
|
|
|
|
// Indicates whether the device is currently connecting to the system.
|
|
std::unique_ptr<bool> connecting;
|
|
|
|
// Indicates whether the device is connectable.
|
|
std::unique_ptr<bool> connectable;
|
|
|
|
// UUIDs of protocols, profiles and services advertised by the device. For
|
|
// classic Bluetooth devices, this list is obtained from EIR data and SDP
|
|
// tables. For Low Energy devices, this list is obtained from AD and GATT
|
|
// primary services. For dual mode devices this may be obtained from both.
|
|
std::unique_ptr<std::vector<std::string>> uuids;
|
|
|
|
// The received signal strength, in dBm. This field is avaliable and valid only
|
|
// during discovery. Outside of discovery it's value is not specified.
|
|
std::unique_ptr<int> inquiry_rssi;
|
|
|
|
// The transmitted power level. This field is avaliable only for LE devices that
|
|
// include this field in AD. It is avaliable and valid only during discovery.
|
|
std::unique_ptr<int> inquiry_tx_power;
|
|
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(Device);
|
|
};
|
|
|
|
struct BluetoothFilter {
|
|
BluetoothFilter();
|
|
~BluetoothFilter();
|
|
BluetoothFilter(BluetoothFilter&& rhs);
|
|
BluetoothFilter& operator=(BluetoothFilter&& rhs);
|
|
|
|
// Populates a BluetoothFilter object from a base::Value. Returns whether
|
|
// |out| was successfully populated.
|
|
static bool Populate(const base::Value& value, BluetoothFilter* out);
|
|
|
|
// Creates a BluetoothFilter object from a base::Value, or NULL on failure.
|
|
static std::unique_ptr<BluetoothFilter> FromValue(const base::Value& value);
|
|
|
|
// Returns a new base::DictionaryValue representing the serialized form of
|
|
// this BluetoothFilter object.
|
|
std::unique_ptr<base::DictionaryValue> ToValue() const;
|
|
|
|
// Type of filter to apply to the device list. Default is all.
|
|
FilterType filter_type;
|
|
|
|
// Maximum number of bluetoth devices to return. Default is 0 (no limit) if
|
|
// unspecified.
|
|
std::unique_ptr<int> limit;
|
|
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(BluetoothFilter);
|
|
};
|
|
|
|
|
|
//
|
|
// Functions
|
|
//
|
|
|
|
namespace GetAdapterState {
|
|
|
|
namespace Results {
|
|
|
|
// Object containing the adapter information.
|
|
std::unique_ptr<base::ListValue> Create(const AdapterState& adapter_info);
|
|
} // namespace Results
|
|
|
|
} // namespace GetAdapterState
|
|
|
|
namespace GetDevice {
|
|
|
|
struct Params {
|
|
static std::unique_ptr<Params> Create(const base::ListValue& args);
|
|
~Params();
|
|
|
|
// Address of device to get.
|
|
std::string device_address;
|
|
|
|
|
|
private:
|
|
Params();
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(Params);
|
|
};
|
|
|
|
namespace Results {
|
|
|
|
// Object containing the device information.
|
|
std::unique_ptr<base::ListValue> Create(const Device& device_info);
|
|
} // namespace Results
|
|
|
|
} // namespace GetDevice
|
|
|
|
namespace GetDevices {
|
|
|
|
struct Params {
|
|
static std::unique_ptr<Params> Create(const base::ListValue& args);
|
|
~Params();
|
|
|
|
// Some criteria to filter the list of returned bluetooth devices. If the filter
|
|
// is not set or set to <code>{}</code>, returned device list will contain all
|
|
// bluetooth devices. Right now this is only supported in ChromeOS, for other
|
|
// platforms, a full list is returned.
|
|
std::unique_ptr<BluetoothFilter> filter;
|
|
|
|
|
|
private:
|
|
Params();
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(Params);
|
|
};
|
|
|
|
namespace Results {
|
|
|
|
// Array of object containing device information.
|
|
std::unique_ptr<base::ListValue> Create(const std::vector<Device>& device_infos);
|
|
} // namespace Results
|
|
|
|
} // namespace GetDevices
|
|
|
|
namespace StartDiscovery {
|
|
|
|
namespace Results {
|
|
|
|
std::unique_ptr<base::ListValue> Create();
|
|
} // namespace Results
|
|
|
|
} // namespace StartDiscovery
|
|
|
|
namespace StopDiscovery {
|
|
|
|
namespace Results {
|
|
|
|
std::unique_ptr<base::ListValue> Create();
|
|
} // namespace Results
|
|
|
|
} // namespace StopDiscovery
|
|
|
|
//
|
|
// Events
|
|
//
|
|
|
|
namespace OnAdapterStateChanged {
|
|
|
|
extern const char kEventName[]; // "bluetooth.onAdapterStateChanged"
|
|
|
|
// The new state of the adapter.
|
|
std::unique_ptr<base::ListValue> Create(const AdapterState& state);
|
|
} // namespace OnAdapterStateChanged
|
|
|
|
namespace OnDeviceAdded {
|
|
|
|
extern const char kEventName[]; // "bluetooth.onDeviceAdded"
|
|
|
|
std::unique_ptr<base::ListValue> Create(const Device& device);
|
|
} // namespace OnDeviceAdded
|
|
|
|
namespace OnDeviceChanged {
|
|
|
|
extern const char kEventName[]; // "bluetooth.onDeviceChanged"
|
|
|
|
std::unique_ptr<base::ListValue> Create(const Device& device);
|
|
} // namespace OnDeviceChanged
|
|
|
|
namespace OnDeviceRemoved {
|
|
|
|
extern const char kEventName[]; // "bluetooth.onDeviceRemoved"
|
|
|
|
std::unique_ptr<base::ListValue> Create(const Device& device);
|
|
} // namespace OnDeviceRemoved
|
|
|
|
} // namespace bluetooth
|
|
} // namespace api
|
|
} // namespace extensions
|
|
#endif // EXTENSIONS_COMMON_API_BLUETOOTH_H__
|