bluetooth/newblued/util.h - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2019 The Chromium OS 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 BLUETOOTH_NEWBLUED_UTIL_H_
 #define BLUETOOTH_NEWBLUED_UTIL_H_

 #include <cstdint>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>

 #include <newblue/bt.h>
 #include <newblue/gatt.h>
 #include <newblue/sg.h>
 #include <newblue/uuid.h>

 #include "bluetooth/common/exported_object_manager_wrapper.h"
 #include "bluetooth/newblued/device_interface_handler.h"
 #include "bluetooth/newblued/gatt_attributes.h"
 #include "bluetooth/newblued/newblue.h"
 #include "bluetooth/newblued/property.h"
 #include "bluetooth/newblued/uuid.h"

 namespace bluetooth {

 constexpr int16_t kInvalidServiceHandle = -1;
 constexpr int32_t kInvalidCharacteristicHandle = -1;
 constexpr int16_t kInvalidDescriptorHandle = -1;

 // TODO(mcchou): Move GATT assigned number and masks to a separate file.
 constexpr uint32_t kAppearanceMask = 0xffc0;

 ////////////////////////////////////////////////////////////////////////////////
 // Miscellaneous utility functions
 ////////////////////////////////////////////////////////////////////////////////

 // Turns the content of |buf| into a uint16_t in host order. This should be used
 // when reading the little-endian data from Bluetooth packet.
 uint16_t GetNumFromLE16(const uint8_t* buf);

 // Turns the content of |buf| into a uint32_t in host order. This should be used
 // when reading the little-endian data from Bluetooth packet.
 uint32_t GetNumFromLE24(const uint8_t* buf);

 // Reverses the content of |buf| and returns bytes in big-endian order. This
 // should be used when reading the little-endian data from Bluetooth packet.
 std::vector<uint8_t> GetBytesFromLE(const uint8_t* buf, size_t buf_len);

 // Retrieves a unique identifier which can be used for tracking the clients and
 // the data associated with them.
 UniqueId GetNextId();

 template <typename T>
 bool GetVariantValue(const brillo::VariantDictionary& dictionary,
                      const std::string& key,
                      T* output) {
   brillo::VariantDictionary::const_iterator it = dictionary.find(key);
   if (it == dictionary.end())
     return false;
   *output = it->second.TryGet<T>();
   return true;
 }

 ////////////////////////////////////////////////////////////////////////////////
 // Parsing Discovered Device Information
 ////////////////////////////////////////////////////////////////////////////////

 // Convert device appearance into icon
 std::string ConvertAppearanceToIcon(uint16_t appearance);

 // Filters out non-ASCII characters from a string by replacing them with spaces.
 std::string ConvertToAsciiString(std::string name);

 std::map<uint16_t, std::vector<uint8_t>> ParseDataIntoManufacturer(
     uint16_t manufacturer_id, std::vector<uint8_t> manufacturer_data);

 // Updates the service UUIDs based on data of EirTypes including
 // UUID16_INCOMPLETE, UUID16_COMPLETE, UUID32_INCOMPLETE, UUID32_COMPLETE,
 // UUID128_INCOMPLETE and UUID128_COMPLETE.
 void ParseDataIntoUuids(std::set<Uuid>* service_uuids,
                         const uint8_t uuid_size,
                         const uint8_t* data,
                         const uint8_t data_len);

 // Updates the service data based on data of EirTypes including SVC_DATA16,
 // SVC_DATA32 and SVC_DATA128.
 void ParseDataIntoServiceData(
     std::map<Uuid, std::vector<uint8_t>>* service_data,
     const uint8_t uuid_size,
     const uint8_t* data,
     const uint8_t data_len);

 ////////////////////////////////////////////////////////////////////////////////
 // D-Bus object path helpers and export helpers.
 ////////////////////////////////////////////////////////////////////////////////

 bool TrimAdapterFromObjectPath(std::string* path);
 std::string TrimDeviceFromObjectPath(std::string* device);
 int32_t TrimServiceFromObjectPath(std::string* service);
 int32_t TrimCharacteristicFromObjectPath(std::string* characteristic);
 int32_t TrimDescriptorFromObjectPath(std::string* descriptor);

 // Converts device object path to device address, e.g.
 // /org/bluez/hci0/dev_00_01_02_03_04_05 will be 00:01:02:03:04:05.
 // Return a valid address if |path| is valid; empty string otherwise.
 std::string ConvertDeviceObjectPathToAddress(const std::string& path);

 // Converts device object path from device address, e.g.
 // 00:01:02:03:04:05 will be /org/bluez/hci0/dev_00_01_02_03_04_05
 dbus::ObjectPath ConvertDeviceAddressToObjectPath(const std::string& address);

 // Converts GATT service object path to service handle, e.g.
 // /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF will return true with
 // device address 00:01:02:03:04:05 and service handle 0X01FF.
 bool ConvertServiceObjectPathToHandle(std::string* address,
                                       uint16_t* handle,
                                       const std::string& path);

 // Converts service handle to service object path, e.g. with device address
 // 00:01:02:03:04:05 and service handle 0X01FF, this will return
 // /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF.
 dbus::ObjectPath ConvertServiceHandleToObjectPath(const std::string& address,
                                                   uint16_t handle);

 // Converts GATT characteristic object path to service handle, e.g.
 // /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123 will return true
 // with device address 00:01:02:03:04:05, service handle 0X01FF and
 // characteristic handle 0x0123.
 bool ConvertCharacteristicObjectPathToHandles(std::string* address,
                                               uint16_t* service_handle,
                                               uint16_t* char_handle,
                                               const std::string& path);

 // Converts characteristic handle to characteristic object path, e.g. with
 // device address 00:01:02:03:04:05, service handle 0X01FF and characteristic
 // handle 0x0123, this will return
 // /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123.
 dbus::ObjectPath ConvertCharacteristicHandleToObjectPath(
     const std::string& address, uint16_t service_handle, uint16_t char_handle);

 // Converts GATT descriptor object path to service handle, e.g.
 // /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123/descriptor0012
 // will return true with device address 00:01:02:03:04:05, service handle
 // 0X01FF, characteristic handle 0x0123 and descriptor handle 0x0012.
 bool ConvertDescriptorObjectPathToHandles(std::string* address,
                                           uint16_t* service_handle,
                                           uint16_t* char_handle,
                                           uint16_t* desc_handle,
                                           const std::string& path);

 // Converts descriptor handle to descriptor object path, e.g. with device
 // address 00:01:02:03:04:05, service handle 0X01FF, characteristic handle
 // 0x0123 and descriptor handle 0x0012, this will return
 // /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123/descriptor0012.
 dbus::ObjectPath ConvertDescriptorHandleToObjectPath(const std::string& address,
                                                      uint16_t service_handle,
                                                      uint16_t char_handle,
                                                      uint16_t desc_handle);

 // Exposes or updates the device object's property depends on the whether it
 // was exposed before or should be forced updated.
 template <typename T>
 void ExportDBusProperty(ExportedInterface* interface,
                         const std::string& property_name,
                         const Property<T>& property,
                         bool force_export) {
   CHECK(interface);
   CHECK(!property_name.empty());

   if (force_export || property.updated()) {
     interface->EnsureExportedPropertyRegistered<T>(property_name)
         ->SetValue(property.value());
   }
 }

 // Exposes or updates the device object's property depends on the whether it
 // was exposed before or should be forced updated. Takes a converter function
 // which converts the value of a property into the value for exposing.
 template <typename T, typename U>
 void ExportDBusProperty(ExportedInterface* interface,
                         const std::string& property_name,
                         const Property<U>& property,
                         T (*converter)(const U&),
                         bool force_export) {
   CHECK(interface);
   CHECK(!property_name.empty());

   if (force_export || property.updated()) {
     interface->EnsureExportedPropertyRegistered<T>(property_name)
         ->SetValue(converter(property.value()));
   }
 }

 ////////////////////////////////////////////////////////////////////////////////
 // Translation between libnewblue types and newblued types.
 ////////////////////////////////////////////////////////////////////////////////

 // Converts device MAC address (e.g. "00:01:02:03:04:05") to struct bt_addr.
 // |result| is valid only if true is returned.
 bool ConvertToBtAddr(bool is_random_address,
                      const std::string& addr,
                      struct bt_addr* result);

 // Converts the uint8_t[6] MAC address into std::string form, e.g.
 // {0x05, 0x04, 0x03, 0x02, 0x01, 0x00} will be 00:01:02:03:04:05.
 std::string ConvertBtAddrToString(const struct bt_addr& addr);

 // Converts struct uuid to bluetooth::Uuid.
 Uuid ConvertToUuid(const struct uuid& uuid);

 // Converts bluetooth::Uuid to struct uuid. If |uuid| is invalid, the return
 // will be zeros.
 struct uuid ConvertToRawUuid(const Uuid& uuid);

 // Converts struct GattTraversedService to bluetooth::GattService.
 std::unique_ptr<GattService> ConvertToGattService(
     const struct GattTraversedService& service);

 // Extracts bytes from |data| without changing the endianess. This does not take
 // the ownership of |data|.
 std::vector<uint8_t> GetBytesFromSg(const sg data);

 void ParseEir(DeviceInfo* device_info, const std::vector<uint8_t>& eir);

 }  // namespace bluetooth

 #endif  // BLUETOOTH_NEWBLUED_UTIL_H_
	// Copyright 2019 The Chromium OS 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 BLUETOOTH_NEWBLUED_UTIL_H_
	#define BLUETOOTH_NEWBLUED_UTIL_H_

	#include <cstdint>
	#include <map>
	#include <memory>
	#include <set>
	#include <string>
	#include <vector>

	#include <newblue/bt.h>
	#include <newblue/gatt.h>
	#include <newblue/sg.h>
	#include <newblue/uuid.h>

	#include "bluetooth/common/exported_object_manager_wrapper.h"
	#include "bluetooth/newblued/device_interface_handler.h"
	#include "bluetooth/newblued/gatt_attributes.h"
	#include "bluetooth/newblued/newblue.h"
	#include "bluetooth/newblued/property.h"
	#include "bluetooth/newblued/uuid.h"

	namespace bluetooth {

	constexpr int16_t kInvalidServiceHandle = -1;
	constexpr int32_t kInvalidCharacteristicHandle = -1;
	constexpr int16_t kInvalidDescriptorHandle = -1;

	// TODO(mcchou): Move GATT assigned number and masks to a separate file.
	constexpr uint32_t kAppearanceMask = 0xffc0;

	////////////////////////////////////////////////////////////////////////////////
	// Miscellaneous utility functions
	////////////////////////////////////////////////////////////////////////////////

	// Turns the content of \|buf\| into a uint16_t in host order. This should be used
	// when reading the little-endian data from Bluetooth packet.
	uint16_t GetNumFromLE16(const uint8_t* buf);

	// Turns the content of \|buf\| into a uint32_t in host order. This should be used
	// when reading the little-endian data from Bluetooth packet.
	uint32_t GetNumFromLE24(const uint8_t* buf);

	// Reverses the content of \|buf\| and returns bytes in big-endian order. This
	// should be used when reading the little-endian data from Bluetooth packet.
	std::vector<uint8_t> GetBytesFromLE(const uint8_t* buf, size_t buf_len);

	// Retrieves a unique identifier which can be used for tracking the clients and
	// the data associated with them.
	UniqueId GetNextId();

	template <typename T>
	bool GetVariantValue(const brillo::VariantDictionary& dictionary,
	const std::string& key,
	T* output) {
	brillo::VariantDictionary::const_iterator it = dictionary.find(key);
	if (it == dictionary.end())
	return false;
	*output = it->second.TryGet<T>();
	return true;
	}

	////////////////////////////////////////////////////////////////////////////////
	// Parsing Discovered Device Information
	////////////////////////////////////////////////////////////////////////////////

	// Convert device appearance into icon
	std::string ConvertAppearanceToIcon(uint16_t appearance);

	// Filters out non-ASCII characters from a string by replacing them with spaces.
	std::string ConvertToAsciiString(std::string name);

	std::map<uint16_t, std::vector<uint8_t>> ParseDataIntoManufacturer(
	uint16_t manufacturer_id, std::vector<uint8_t> manufacturer_data);

	// Updates the service UUIDs based on data of EirTypes including
	// UUID16_INCOMPLETE, UUID16_COMPLETE, UUID32_INCOMPLETE, UUID32_COMPLETE,
	// UUID128_INCOMPLETE and UUID128_COMPLETE.
	void ParseDataIntoUuids(std::set<Uuid>* service_uuids,
	const uint8_t uuid_size,
	const uint8_t* data,
	const uint8_t data_len);

	// Updates the service data based on data of EirTypes including SVC_DATA16,
	// SVC_DATA32 and SVC_DATA128.
	void ParseDataIntoServiceData(
	std::map<Uuid, std::vector<uint8_t>>* service_data,
	const uint8_t uuid_size,
	const uint8_t* data,
	const uint8_t data_len);

	////////////////////////////////////////////////////////////////////////////////
	// D-Bus object path helpers and export helpers.
	////////////////////////////////////////////////////////////////////////////////

	bool TrimAdapterFromObjectPath(std::string* path);
	std::string TrimDeviceFromObjectPath(std::string* device);
	int32_t TrimServiceFromObjectPath(std::string* service);
	int32_t TrimCharacteristicFromObjectPath(std::string* characteristic);
	int32_t TrimDescriptorFromObjectPath(std::string* descriptor);

	// Converts device object path to device address, e.g.
	// /org/bluez/hci0/dev_00_01_02_03_04_05 will be 00:01:02:03:04:05.
	// Return a valid address if \|path\| is valid; empty string otherwise.
	std::string ConvertDeviceObjectPathToAddress(const std::string& path);

	// Converts device object path from device address, e.g.
	// 00:01:02:03:04:05 will be /org/bluez/hci0/dev_00_01_02_03_04_05
	dbus::ObjectPath ConvertDeviceAddressToObjectPath(const std::string& address);

	// Converts GATT service object path to service handle, e.g.
	// /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF will return true with
	// device address 00:01:02:03:04:05 and service handle 0X01FF.
	bool ConvertServiceObjectPathToHandle(std::string* address,
	uint16_t* handle,
	const std::string& path);

	// Converts service handle to service object path, e.g. with device address
	// 00:01:02:03:04:05 and service handle 0X01FF, this will return
	// /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF.
	dbus::ObjectPath ConvertServiceHandleToObjectPath(const std::string& address,
	uint16_t handle);

	// Converts GATT characteristic object path to service handle, e.g.
	// /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123 will return true
	// with device address 00:01:02:03:04:05, service handle 0X01FF and
	// characteristic handle 0x0123.
	bool ConvertCharacteristicObjectPathToHandles(std::string* address,
	uint16_t* service_handle,
	uint16_t* char_handle,
	const std::string& path);

	// Converts characteristic handle to characteristic object path, e.g. with
	// device address 00:01:02:03:04:05, service handle 0X01FF and characteristic
	// handle 0x0123, this will return
	// /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123.
	dbus::ObjectPath ConvertCharacteristicHandleToObjectPath(
	const std::string& address, uint16_t service_handle, uint16_t char_handle);

	// Converts GATT descriptor object path to service handle, e.g.
	// /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123/descriptor0012
	// will return true with device address 00:01:02:03:04:05, service handle
	// 0X01FF, characteristic handle 0x0123 and descriptor handle 0x0012.
	bool ConvertDescriptorObjectPathToHandles(std::string* address,
	uint16_t* service_handle,
	uint16_t* char_handle,
	uint16_t* desc_handle,
	const std::string& path);

	// Converts descriptor handle to descriptor object path, e.g. with device
	// address 00:01:02:03:04:05, service handle 0X01FF, characteristic handle
	// 0x0123 and descriptor handle 0x0012, this will return
	// /org/bluez/hci0/dev_00_01_02_03_04_05/service01FF/char0123/descriptor0012.
	dbus::ObjectPath ConvertDescriptorHandleToObjectPath(const std::string& address,
	uint16_t service_handle,
	uint16_t char_handle,
	uint16_t desc_handle);

	// Exposes or updates the device object's property depends on the whether it
	// was exposed before or should be forced updated.
	template <typename T>
	void ExportDBusProperty(ExportedInterface* interface,
	const std::string& property_name,
	const Property<T>& property,
	bool force_export) {
	CHECK(interface);
	CHECK(!property_name.empty());

	if (force_export \|\| property.updated()) {
	interface->EnsureExportedPropertyRegistered<T>(property_name)
	->SetValue(property.value());
	}
	}

	// Exposes or updates the device object's property depends on the whether it
	// was exposed before or should be forced updated. Takes a converter function
	// which converts the value of a property into the value for exposing.
	template <typename T, typename U>
	void ExportDBusProperty(ExportedInterface* interface,
	const std::string& property_name,
	const Property<U>& property,
	T (*converter)(const U&),
	bool force_export) {
	CHECK(interface);
	CHECK(!property_name.empty());

	if (force_export \|\| property.updated()) {
	interface->EnsureExportedPropertyRegistered<T>(property_name)
	->SetValue(converter(property.value()));
	}
	}

	////////////////////////////////////////////////////////////////////////////////
	// Translation between libnewblue types and newblued types.
	////////////////////////////////////////////////////////////////////////////////

	// Converts device MAC address (e.g. "00:01:02:03:04:05") to struct bt_addr.
	// \|result\| is valid only if true is returned.
	bool ConvertToBtAddr(bool is_random_address,
	const std::string& addr,
	struct bt_addr* result);

	// Converts the uint8_t[6] MAC address into std::string form, e.g.
	// {0x05, 0x04, 0x03, 0x02, 0x01, 0x00} will be 00:01:02:03:04:05.
	std::string ConvertBtAddrToString(const struct bt_addr& addr);

	// Converts struct uuid to bluetooth::Uuid.
	Uuid ConvertToUuid(const struct uuid& uuid);

	// Converts bluetooth::Uuid to struct uuid. If \|uuid\| is invalid, the return
	// will be zeros.
	struct uuid ConvertToRawUuid(const Uuid& uuid);

	// Converts struct GattTraversedService to bluetooth::GattService.
	std::unique_ptr<GattService> ConvertToGattService(
	const struct GattTraversedService& service);

	// Extracts bytes from \|data\| without changing the endianess. This does not take
	// the ownership of \|data\|.
	std::vector<uint8_t> GetBytesFromSg(const sg data);

	void ParseEir(DeviceInfo* device_info, const std::vector<uint8_t>& eir);

	} // namespace bluetooth

	#endif // BLUETOOTH_NEWBLUED_UTIL_H_