1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// Copyright 2014 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 DEVICE_BLUETOOTH_BLUETOOTH_LOW_ENERGY_WIN_H_
#define DEVICE_BLUETOOTH_BLUETOOTH_LOW_ENERGY_WIN_H_
#include <stddef.h>
#include <stdint.h>
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "device/bluetooth/bluetooth_export.h"
#include "device/bluetooth/bluetooth_low_energy_defs_win.h"
namespace device {
namespace win {
// Represents a device registry property value
class DEVICE_BLUETOOTH_EXPORT DeviceRegistryPropertyValue {
public:
// Creates a property value instance, where |property_type| is one of REG_xxx
// registry value type (e.g. REG_SZ, REG_DWORD), |value| is a byte array
// containing the property value and |value_size| is the number of bytes in
// |value|. Note the returned instance takes ownership of the bytes in
// |value|.
static scoped_ptr<DeviceRegistryPropertyValue> Create(
DWORD property_type,
scoped_ptr<uint8_t[]> value,
size_t value_size);
~DeviceRegistryPropertyValue();
// Returns the vaue type a REG_xxx value (e.g. REG_SZ, REG_DWORD, ...)
DWORD property_type() const { return property_type_; }
std::string AsString() const;
DWORD AsDWORD() const;
private:
DeviceRegistryPropertyValue(DWORD property_type,
scoped_ptr<uint8_t[]> value,
size_t value_size);
DWORD property_type_;
scoped_ptr<uint8_t[]> value_;
size_t value_size_;
DISALLOW_COPY_AND_ASSIGN(DeviceRegistryPropertyValue);
};
// Represents the value associated to a DEVPROPKEY.
class DEVICE_BLUETOOTH_EXPORT DevicePropertyValue {
public:
// Creates a property value instance, where |property_type| is one of
// DEVPROP_TYPE_xxx value type , |value| is a byte array containing the
// property value and |value_size| is the number of bytes in |value|. Note the
// returned instance takes ownership of the bytes in |value|.
DevicePropertyValue(DEVPROPTYPE property_type,
scoped_ptr<uint8_t[]> value,
size_t value_size);
~DevicePropertyValue();
DEVPROPTYPE property_type() const { return property_type_; }
uint32_t AsUint32() const;
private:
DEVPROPTYPE property_type_;
scoped_ptr<uint8_t[]> value_;
size_t value_size_;
DISALLOW_COPY_AND_ASSIGN(DevicePropertyValue);
};
struct DEVICE_BLUETOOTH_EXPORT BluetoothLowEnergyServiceInfo {
BluetoothLowEnergyServiceInfo();
~BluetoothLowEnergyServiceInfo();
BTH_LE_UUID uuid;
// Attribute handle uniquely identifies this service on the device.
USHORT attribute_handle = 0;
};
struct DEVICE_BLUETOOTH_EXPORT BluetoothLowEnergyDeviceInfo {
BluetoothLowEnergyDeviceInfo();
~BluetoothLowEnergyDeviceInfo();
base::FilePath path;
std::string id;
std::string friendly_name;
BLUETOOTH_ADDRESS address;
bool visible;
bool authenticated;
bool connected;
};
bool DEVICE_BLUETOOTH_EXPORT
ExtractBluetoothAddressFromDeviceInstanceIdForTesting(
const std::string& instance_id,
BLUETOOTH_ADDRESS* btha,
std::string* error);
// Wraps Windows APIs used to access Bluetooth Low Energy devices, providing an
// interface that can be replaced with fakes in tests.
class DEVICE_BLUETOOTH_EXPORT BluetoothLowEnergyWrapper {
public:
static BluetoothLowEnergyWrapper* GetInstance();
static void DeleteInstance();
static void SetInstanceForTest(BluetoothLowEnergyWrapper* instance);
// Returns true only on Windows platforms supporting Bluetooth Low Energy.
virtual bool IsBluetoothLowEnergySupported();
// Enumerates the list of known (i.e. already paired) Bluetooth LE devices on
// this machine. In case of error, returns false and sets |error| with an
// error message describing the problem.
// Note: This function returns an error if Bluetooth Low Energy is not
// supported on this Windows platform.
virtual bool EnumerateKnownBluetoothLowEnergyDevices(
ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
std::string* error);
// Enumerates the list of known Bluetooth LE GATT service devices on this
// machine (a Bluetooth LE device usually has more than one GATT
// services that each of them has a device interface on the machine). In case
// of error, returns false and sets |error| with an error message describing
// the problem.
// Note: This function returns an error if Bluetooth Low Energy is not
// supported on this Windows platform.
virtual bool EnumerateKnownBluetoothLowEnergyGattServiceDevices(
ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
std::string* error);
// Enumerates the list of known (i.e. cached) GATT services for a given
// Bluetooth LE device |device_path| into |services|. In case of error,
// returns false and sets |error| with an error message describing the
// problem.
// Note: This function returns an error if Bluetooth Low Energy is not
// supported on this Windows platform.
virtual bool EnumerateKnownBluetoothLowEnergyServices(
const base::FilePath& device_path,
ScopedVector<BluetoothLowEnergyServiceInfo>* services,
std::string* error);
// Reads characteristics of |service| with service device path |service_path|.
// The result will be stored in |*out_included_characteristics| and
// |*out_counts|.
virtual HRESULT ReadCharacteristicsOfAService(
base::FilePath& service_path,
const PBTH_LE_GATT_SERVICE service,
scoped_ptr<BTH_LE_GATT_CHARACTERISTIC>* out_included_characteristics,
USHORT* out_counts);
protected:
BluetoothLowEnergyWrapper();
virtual ~BluetoothLowEnergyWrapper();
};
} // namespace win
} // namespace device
#endif // DEVICE_BLUETOOTH_BLUETOOTH_LOW_ENERGY_WIN_H_
|
