am 6d443336: service: Rename Uuid to UUID (4a7a07d5) · Commits · e / os / android_packages_modules_Bluetooth

system/service/gatt_server.cpp

+17 −17

Original line number	Original line	Diff line number	Diff line
	@@ -82,7 +82,7 @@ namespace bluetooth {
	namespace gatt {		namespace gatt {

	struct Characteristic {		struct Characteristic {
	Uuid uuid;		UUID uuid;
	int blob_section;		int blob_section;
	std::vector<uint8_t> blob;		std::vector<uint8_t> blob;

	@@ -97,12 +97,12 @@ struct ServerInternals {
	~ServerInternals();		~ServerInternals();
	int Initialize();		int Initialize();
	bt_status_t AddCharacteristic(		bt_status_t AddCharacteristic(
	const Uuid& uuid,		const UUID& uuid,
	int properties,		int properties,
	int permissions);		int permissions);

	// This maps API attribute UUIDs to BlueDroid handles.		// This maps API attribute UUIDs to BlueDroid handles.
	std::map<Uuid, int> uuid_to_attribute;		std::map<UUID, int> uuid_to_attribute;

	// The attribute cache, indexed by BlueDroid handles.		// The attribute cache, indexed by BlueDroid handles.
	std::unordered_map<int, Characteristic> characteristics;		std::unordered_map<int, Characteristic> characteristics;
	@@ -112,7 +112,7 @@ struct ServerInternals {

	ScanResults scan_results;		ScanResults scan_results;

	Uuid last_write;		UUID last_write;
	const btgatt_interface_t *gatt;		const btgatt_interface_t *gatt;
	int server_if;		int server_if;
	int client_if;		int client_if;
	@@ -231,7 +231,7 @@ void RequestWriteCallback(int conn_id, int trans_id, bt_bdaddr_t *bda,
	} else if (!is_prep) {		} else if (!is_prep) {
	// This is a single frame characteristic write.		// This is a single frame characteristic write.
	// Notify upwards because we're done now.		// Notify upwards because we're done now.
	const bluetooth::Uuid::Uuid128Bit &attr_uuid = ch.uuid.GetFullBigEndian();		const bluetooth::UUID::UUID128Bit &attr_uuid = ch.uuid.GetFullBigEndian();
	int status = write(g_internal->pipefd[kPipeWriteEnd], attr_uuid.data(),		int status = write(g_internal->pipefd[kPipeWriteEnd], attr_uuid.data(),
	attr_uuid.size());		attr_uuid.size());
	if (-1 == status)		if (-1 == status)
	@@ -272,7 +272,7 @@ void RequestExecWriteCallback(int conn_id, int trans_id, bt_bdaddr_t *bda,

	std::lock_guard<std::mutex> lock(g_internal->lock);		std::lock_guard<std::mutex> lock(g_internal->lock);
	// Communicate the attribute UUID as notification of a write update.		// Communicate the attribute UUID as notification of a write update.
	const bluetooth::Uuid::Uuid128Bit uuid =		const bluetooth::UUID::UUID128Bit uuid =
	g_internal->last_write.GetFullBigEndian();		g_internal->last_write.GetFullBigEndian();
	int status = write(g_internal->pipefd[kPipeWriteEnd],		int status = write(g_internal->pipefd[kPipeWriteEnd],
	uuid.data(), uuid.size());		uuid.data(), uuid.size());
	@@ -298,7 +298,7 @@ void CharacteristicAddedCallback(int status, int server_if, bt_uuid_t *uuid,
	"%s: status:%d server_if:%d service_handle:%d char_handle:%d", __func__,		"%s: status:%d server_if:%d service_handle:%d char_handle:%d", __func__,
	status, server_if, srvc_handle, char_handle);		status, server_if, srvc_handle, char_handle);

	bluetooth::Uuid id(*uuid);		bluetooth::UUID id(*uuid);

	std::lock_guard<std::mutex> lock(g_internal->lock);		std::lock_guard<std::mutex> lock(g_internal->lock);

	@@ -508,7 +508,7 @@ int ServerInternals::Initialize() {
	}		}

	bt_status_t ServerInternals::AddCharacteristic(		bt_status_t ServerInternals::AddCharacteristic(
	const Uuid& uuid,		const UUID& uuid,
	int properties,		int properties,
	int permissions) {		int permissions) {
	bt_uuid_t c_uuid = uuid.GetBlueDroid();		bt_uuid_t c_uuid = uuid.GetBlueDroid();
	@@ -538,7 +538,7 @@ Server::Server() : internal_(nullptr) {}

	Server::~Server() {}		Server::~Server() {}

	bool Server::Initialize(const Uuid& service_id, int* gatt_pipe) {		bool Server::Initialize(const UUID& service_id, int* gatt_pipe) {
	internal_.reset(new ServerInternals);		internal_.reset(new ServerInternals);
	if (!internal_) {		if (!internal_) {
	LOG_ERROR(LOG_TAG, "Error creating internals");		LOG_ERROR(LOG_TAG, "Error creating internals");
	@@ -573,7 +573,7 @@ bool Server::Initialize(const Uuid& service_id, int* gatt_pipe) {
	return true;		return true;
	}		}

	bool Server::SetAdvertisement(const std::vector<Uuid>& ids,		bool Server::SetAdvertisement(const std::vector<UUID>& ids,
	const std::vector<uint8_t>& service_data,		const std::vector<uint8_t>& service_data,
	const std::vector<uint8_t>& manufacturer_data,		const std::vector<uint8_t>& manufacturer_data,
	bool transmit_name) {		bool transmit_name) {
	@@ -581,7 +581,7 @@ bool Server::SetAdvertisement(const std::vector<Uuid>& ids,
	auto mutable_manufacturer_data = manufacturer_data;		auto mutable_manufacturer_data = manufacturer_data;
	auto mutable_service_data = service_data;		auto mutable_service_data = service_data;

	for (const Uuid &id : ids) {		for (const UUID &id : ids) {
	const auto le_id = id.GetFullLittleEndian();		const auto le_id = id.GetFullLittleEndian();
	id_data.insert(id_data.end(), le_id.begin(), le_id.end());		id_data.insert(id_data.end(), le_id.begin(), le_id.end());
	}		}
	@@ -607,7 +607,7 @@ bool Server::SetAdvertisement(const std::vector<Uuid>& ids,
	return true;		return true;
	}		}

	bool Server::SetScanResponse(const std::vector<Uuid>& ids,		bool Server::SetScanResponse(const std::vector<UUID>& ids,
	const std::vector<uint8_t>& service_data,		const std::vector<uint8_t>& service_data,
	const std::vector<uint8_t>& manufacturer_data,		const std::vector<uint8_t>& manufacturer_data,
	bool transmit_name) {		bool transmit_name) {
	@@ -615,7 +615,7 @@ bool Server::SetScanResponse(const std::vector<Uuid>& ids,
	auto mutable_manufacturer_data = manufacturer_data;		auto mutable_manufacturer_data = manufacturer_data;
	auto mutable_service_data = service_data;		auto mutable_service_data = service_data;

	for (const Uuid &id : ids) {		for (const UUID &id : ids) {
	const auto le_id = id.GetFullLittleEndian();		const auto le_id = id.GetFullLittleEndian();
	id_data.insert(id_data.end(), le_id.begin(), le_id.end());		id_data.insert(id_data.end(), le_id.begin(), le_id.end());
	}		}
	@@ -642,7 +642,7 @@ bool Server::SetScanResponse(const std::vector<Uuid>& ids,
	}		}

	bool Server::AddCharacteristic(		bool Server::AddCharacteristic(
	const Uuid &id, int properties, int permissions) {		const UUID &id, int properties, int permissions) {
	std::unique_lock<std::mutex> lock(internal_->lock);		std::unique_lock<std::mutex> lock(internal_->lock);
	bt_status_t btstat = internal_->AddCharacteristic(		bt_status_t btstat = internal_->AddCharacteristic(
	id, properties, permissions);		id, properties, permissions);
	@@ -657,7 +657,7 @@ bool Server::AddCharacteristic(
	return true;		return true;
	}		}

	bool Server::AddBlob(const Uuid &id, const Uuid &control_id, int properties,		bool Server::AddBlob(const UUID &id, const UUID &control_id, int properties,
	int permissions) {		int permissions) {
	std::unique_lock<std::mutex> lock(internal_->lock);		std::unique_lock<std::mutex> lock(internal_->lock);

	@@ -746,7 +746,7 @@ bool Server::GetScanResults(ScanResults *results) {
	return true;		return true;
	}		}

	bool Server::SetCharacteristicValue(const Uuid &id,		bool Server::SetCharacteristicValue(const UUID &id,
	const std::vector<uint8_t> &value) {		const std::vector<uint8_t> &value) {
	std::lock_guard<std::mutex> lock(internal_->lock);		std::lock_guard<std::mutex> lock(internal_->lock);
	const int attribute_id = internal_->uuid_to_attribute[id];		const int attribute_id = internal_->uuid_to_attribute[id];
	@@ -769,7 +769,7 @@ bool Server::SetCharacteristicValue(const Uuid &id,
	return true;		return true;
	}		}

	bool Server::GetCharacteristicValue(const Uuid &id, std::vector<uint8_t> *value) {		bool Server::GetCharacteristicValue(const UUID &id, std::vector<uint8_t> *value) {
	std::lock_guard<std::mutex> lock(internal_->lock);		std::lock_guard<std::mutex> lock(internal_->lock);
	const int attribute_id = internal_->uuid_to_attribute[id];		const int attribute_id = internal_->uuid_to_attribute[id];
	*value = internal_->characteristics[attribute_id].blob;		*value = internal_->characteristics[attribute_id].blob;

system/service/gatt_server.h

+7 −7

system/service/ipc/unix_ipc_host.cpp

+12 −12

Original line number	Original line	Diff line number	Diff line
	@@ -39,7 +39,7 @@
	#include "service/uuid.h"		#include "service/uuid.h"

	using bluetooth::Adapter;		using bluetooth::Adapter;
	using bluetooth::Uuid;		using bluetooth::UUID;

	using namespace bluetooth::gatt;		using namespace bluetooth::gatt;

	@@ -115,7 +115,7 @@ bool UnixIPCHost::OnCreateService(const std::string& service_uuid) {

	int gattfd;		int gattfd;
	bool status = gatt_servers_[service_uuid]->Initialize(		bool status = gatt_servers_[service_uuid]->Initialize(
	Uuid(service_uuid), &gattfd);		UUID(service_uuid), &gattfd);
	if (!status) {		if (!status) {
	LOG_ERROR(LOG_TAG, "Failed to initialize bluetooth");		LOG_ERROR(LOG_TAG, "Failed to initialize bluetooth");
	return false;		return false;
	@@ -161,10 +161,10 @@ bool UnixIPCHost::OnAddCharacteristic(const std::string& service_uuid,

	if (control_uuid.empty()) {		if (control_uuid.empty()) {
	gatt_servers_[service_uuid]->AddCharacteristic(		gatt_servers_[service_uuid]->AddCharacteristic(
	Uuid(characteristic_uuid), properties_mask, permissions_mask);		UUID(characteristic_uuid), properties_mask, permissions_mask);
	} else {		} else {
	gatt_servers_[service_uuid]->AddBlob(Uuid(characteristic_uuid),		gatt_servers_[service_uuid]->AddBlob(UUID(characteristic_uuid),
	Uuid(control_uuid), properties_mask,		UUID(control_uuid), properties_mask,
	permissions_mask);		permissions_mask);
	}		}
	return true;		return true;
	@@ -176,7 +176,7 @@ bool UnixIPCHost::OnSetCharacteristicValue(const std::string& service_uuid,
	std::string decoded_data;		std::string decoded_data;
	base::Base64Decode(value, &decoded_data);		base::Base64Decode(value, &decoded_data);
	std::vector<uint8_t> blob_data(decoded_data.begin(), decoded_data.end());		std::vector<uint8_t> blob_data(decoded_data.begin(), decoded_data.end());
	gatt_servers_[service_uuid]->SetCharacteristicValue(Uuid(characteristic_uuid),		gatt_servers_[service_uuid]->SetCharacteristicValue(UUID(characteristic_uuid),
	blob_data);		blob_data);
	return true;		return true;
	}		}
	@@ -192,8 +192,8 @@ bool UnixIPCHost::OnSetAdvertisement(const std::string& service_uuid,
	std::vector<std::string> advertise_uuid_tokens;		std::vector<std::string> advertise_uuid_tokens;
	base::SplitString(advertise_uuids, '.', &advertise_uuid_tokens);		base::SplitString(advertise_uuids, '.', &advertise_uuid_tokens);

	// string -> vector<Uuid>		// string -> vector<UUID>
	std::vector<Uuid> ids;		std::vector<UUID> ids;
	for (const auto& uuid_token : advertise_uuid_tokens)		for (const auto& uuid_token : advertise_uuid_tokens)
	ids.emplace_back(uuid_token);		ids.emplace_back(uuid_token);

	@@ -220,8 +220,8 @@ bool UnixIPCHost::OnSetScanResponse(const std::string& service_uuid,
	std::vector<std::string> scan_response_uuid_tokens;		std::vector<std::string> scan_response_uuid_tokens;
	base::SplitString(scan_response_uuids, '.', &scan_response_uuid_tokens);		base::SplitString(scan_response_uuids, '.', &scan_response_uuid_tokens);

	// string -> vector<Uuid>		// string -> vector<UUID>
	std::vector<Uuid> ids;		std::vector<UUID> ids;
	for (const auto& uuid_token : scan_response_uuid_tokens)		for (const auto& uuid_token : scan_response_uuid_tokens)
	ids.emplace_back(uuid_token);		ids.emplace_back(uuid_token);

	@@ -307,7 +307,7 @@ bool UnixIPCHost::OnMessage() {
	}		}

	bool UnixIPCHost::OnGattWrite() {		bool UnixIPCHost::OnGattWrite() {
	Uuid::Uuid128Bit id;		UUID::UUID128Bit id;
	int r = read(pfds_[kFdGatt].fd, id.data(), id.size());		int r = read(pfds_[kFdGatt].fd, id.data(), id.size());
	if (r != id.size()) {		if (r != id.size()) {
	LOG_ERROR(LOG_TAG, "Error reading GATT attribute ID");		LOG_ERROR(LOG_TAG, "Error reading GATT attribute ID");
	@@ -317,7 +317,7 @@ bool UnixIPCHost::OnGattWrite() {
	std::vector<uint8_t> value;		std::vector<uint8_t> value;
	// TODO(icoolidge): Generalize this for multiple clients.		// TODO(icoolidge): Generalize this for multiple clients.
	auto server = gatt_servers_.begin();		auto server = gatt_servers_.begin();
	server->second->GetCharacteristicValue(Uuid(id), &value);		server->second->GetCharacteristicValue(UUID(id), &value);
	const std::string value_string(value.begin(), value.end());		const std::string value_string(value.begin(), value.end());
	std::string encoded_value;		std::string encoded_value;
	base::Base64Encode(value_string, &encoded_value);		base::Base64Encode(value_string, &encoded_value);

system/service/test/uuid_unittest.cpp

+26 −26

Original line number	Original line	Diff line number	Diff line
	@@ -25,99 +25,99 @@ using namespace bluetooth;

	namespace {		namespace {

	const std::array<uint8_t, Uuid::kUuid128Octets> kBtSigBaseUuid = {		const std::array<uint8_t, UUID::kUUID128Octets> kBtSigBaseUUID = {
	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
	0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb, }		0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb, }
	};		};

	} // namespace		} // namespace

	// Verify that an uninitialized Uuid is equal		// Verify that an uninitialized UUID is equal
	// To the BT SIG Base UUID.		// To the BT SIG Base UUID.
	TEST(UuidTest, DefaultUuid) {		TEST(UUIDTest, DefaultUUID) {
	Uuid uuid;		UUID uuid;
	ASSERT_TRUE(uuid.GetFullBigEndian() == kBtSigBaseUuid);		ASSERT_TRUE(uuid.GetFullBigEndian() == kBtSigBaseUUID);
	}		}

	// Verify that we initialize a 16-bit UUID in a		// Verify that we initialize a 16-bit UUID in a
	// way consistent with how we read it.		// way consistent with how we read it.
	TEST(UuidTest, Init16Bit) {		TEST(UUIDTest, Init16Bit) {
	auto my_uuid_16 = kBtSigBaseUuid;		auto my_uuid_16 = kBtSigBaseUUID;
	my_uuid_16[2] = 0xde;		my_uuid_16[2] = 0xde;
	my_uuid_16[3] = 0xad;		my_uuid_16[3] = 0xad;
	Uuid uuid(Uuid::Uuid16Bit({{ 0xde, 0xad }}));		UUID uuid(UUID::UUID16Bit({{ 0xde, 0xad }}));
	ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);		ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);
	}		}

	// Verify that we initialize a 16-bit UUID in a		// Verify that we initialize a 16-bit UUID in a
	// way consistent with how we read it.		// way consistent with how we read it.
	TEST(UuidTest, Init16BitString) {		TEST(UUIDTest, Init16BitString) {
	auto my_uuid_16 = kBtSigBaseUuid;		auto my_uuid_16 = kBtSigBaseUUID;
	my_uuid_16[2] = 0xde;		my_uuid_16[2] = 0xde;
	my_uuid_16[3] = 0xad;		my_uuid_16[3] = 0xad;
	Uuid uuid("dead");		UUID uuid("dead");
	ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);		ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);
	}		}


	// Verify that we initialize a 32-bit UUID in a		// Verify that we initialize a 32-bit UUID in a
	// way consistent with how we read it.		// way consistent with how we read it.
	TEST(UuidTest, Init32Bit) {		TEST(UUIDTest, Init32Bit) {
	auto my_uuid_32 = kBtSigBaseUuid;		auto my_uuid_32 = kBtSigBaseUUID;
	my_uuid_32[0] = 0xde;		my_uuid_32[0] = 0xde;
	my_uuid_32[1] = 0xad;		my_uuid_32[1] = 0xad;
	my_uuid_32[2] = 0xbe;		my_uuid_32[2] = 0xbe;
	my_uuid_32[3] = 0xef;		my_uuid_32[3] = 0xef;
	Uuid uuid(Uuid::Uuid32Bit({{ 0xde, 0xad, 0xbe, 0xef }}));		UUID uuid(UUID::UUID32Bit({{ 0xde, 0xad, 0xbe, 0xef }}));
	ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_32);		ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_32);
	}		}

	// Verify correct reading of a 32-bit UUID initialized from string.		// Verify correct reading of a 32-bit UUID initialized from string.
	TEST(UuidTest, Init32BitString) {		TEST(UUIDTest, Init32BitString) {
	auto my_uuid_32 = kBtSigBaseUuid;		auto my_uuid_32 = kBtSigBaseUUID;
	my_uuid_32[0] = 0xde;		my_uuid_32[0] = 0xde;
	my_uuid_32[1] = 0xad;		my_uuid_32[1] = 0xad;
	my_uuid_32[2] = 0xbe;		my_uuid_32[2] = 0xbe;
	my_uuid_32[3] = 0xef;		my_uuid_32[3] = 0xef;
	Uuid uuid("deadbeef");		UUID uuid("deadbeef");
	ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_32);		ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_32);
	}		}

	// Verify that we initialize a 128-bit UUID in a		// Verify that we initialize a 128-bit UUID in a
	// way consistent with how we read it.		// way consistent with how we read it.
	TEST(UuidTest, Init128Bit) {		TEST(UUIDTest, Init128Bit) {
	auto my_uuid_128 = kBtSigBaseUuid;		auto my_uuid_128 = kBtSigBaseUUID;
	for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {		for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
	my_uuid_128[i] = i;		my_uuid_128[i] = i;
	}		}

	Uuid uuid(my_uuid_128);		UUID uuid(my_uuid_128);
	ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);		ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);
	}		}

	// Verify that we initialize a 128-bit UUID in a		// Verify that we initialize a 128-bit UUID in a
	// way consistent with how we read it as LE.		// way consistent with how we read it as LE.
	TEST(UuidTest, Init128BitLittleEndian) {		TEST(UUIDTest, Init128BitLittleEndian) {
	auto my_uuid_128 = kBtSigBaseUuid;		auto my_uuid_128 = kBtSigBaseUUID;
	for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {		for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
	my_uuid_128[i] = i;		my_uuid_128[i] = i;
	}		}

	Uuid uuid(my_uuid_128);		UUID uuid(my_uuid_128);
	std::reverse(my_uuid_128.begin(), my_uuid_128.end());		std::reverse(my_uuid_128.begin(), my_uuid_128.end());
	ASSERT_TRUE(uuid.GetFullLittleEndian() == my_uuid_128);		ASSERT_TRUE(uuid.GetFullLittleEndian() == my_uuid_128);
	}		}

	// Verify that we initialize a 128-bit UUID in a		// Verify that we initialize a 128-bit UUID in a
	// way consistent with how we read it.		// way consistent with how we read it.
	TEST(UuidTest, Init128BitString) {		TEST(UUIDTest, Init128BitString) {
	auto my_uuid_128 = kBtSigBaseUuid;		auto my_uuid_128 = kBtSigBaseUUID;
	for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {		for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
	my_uuid_128[i] = i;		my_uuid_128[i] = i;
	}		}

	std::string uuid_text("000102030405060708090A0B0C0D0E0F");		std::string uuid_text("000102030405060708090A0B0C0D0E0F");
	ASSERT_TRUE(uuid_text.size() == (16 * 2));		ASSERT_TRUE(uuid_text.size() == (16 * 2));
	Uuid uuid(uuid_text);		UUID uuid(uuid_text);
	ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);		ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);
	}		}

system/service/uuid.cpp

+16 −15

Original line number	Original line	Diff line number	Diff line
	@@ -13,7 +13,8 @@
	// See the License for the specific language governing permissions and		// See the License for the specific language governing permissions and
	// limitations under the License.		// limitations under the License.
	//		//
	#include "uuid.h"
			#include "service/uuid.h"

	#include <algorithm>		#include <algorithm>
	#include <array>		#include <array>
	@@ -22,17 +23,17 @@

	namespace bluetooth {		namespace bluetooth {

	void Uuid::InitializeDefault() {		void UUID::InitializeDefault() {
	// Initialize to base bluetooth UUID.		// Initialize to base bluetooth UUID.
	id_ = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,		id_ = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
	0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb}};		0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb}};
	}		}

	Uuid::Uuid() {		UUID::UUID() {
	InitializeDefault();		InitializeDefault();
	}		}

	Uuid::Uuid(const std::string& uuid) {		UUID::UUID(const std::string& uuid) {
	InitializeDefault();		InitializeDefault();
	const int start_index = uuid.size() == 4 ? 2 : 0;		const int start_index = uuid.size() == 4 ? 2 : 0;
	const size_t copy_size = std::min(id_.size(), uuid.size() / 2);		const size_t copy_size = std::min(id_.size(), uuid.size() / 2);
	@@ -42,44 +43,44 @@ Uuid::Uuid(const std::string& uuid) {
	}		}
	}		}

	Uuid::Uuid(const bt_uuid_t& uuid) {		UUID::UUID(const bt_uuid_t& uuid) {
	std::reverse_copy(uuid.uu, uuid.uu + sizeof(uuid.uu), id_.begin());		std::reverse_copy(uuid.uu, uuid.uu + sizeof(uuid.uu), id_.begin());
	}		}

	Uuid::Uuid(const Uuid::Uuid16Bit& uuid) {		UUID::UUID(const UUID::UUID16Bit& uuid) {
	InitializeDefault();		InitializeDefault();
	std::copy(uuid.begin(), uuid.end(), id_.begin() + kUuid16Octets);		std::copy(uuid.begin(), uuid.end(), id_.begin() + kUUID16Octets);
	}		}

	Uuid::Uuid(const Uuid::Uuid32Bit& uuid) {		UUID::UUID(const UUID::UUID32Bit& uuid) {
	InitializeDefault();		InitializeDefault();
	std::copy(uuid.begin(), uuid.end(), id_.begin());		std::copy(uuid.begin(), uuid.end(), id_.begin());
	}		}

	Uuid::Uuid(const Uuid::Uuid128Bit& uuid) : id_(uuid) {}		UUID::UUID(const UUID::UUID128Bit& uuid) : id_(uuid) {}

	const Uuid::Uuid128Bit Uuid::GetFullBigEndian() const {		const UUID::UUID128Bit UUID::GetFullBigEndian() const {
	return id_;		return id_;
	}		}

	const Uuid::Uuid128Bit Uuid::GetFullLittleEndian() const {		const UUID::UUID128Bit UUID::GetFullLittleEndian() const {
	Uuid::Uuid128Bit ret;		UUID::UUID128Bit ret;
	std::reverse_copy(id_.begin(), id_.end(), ret.begin());		std::reverse_copy(id_.begin(), id_.end(), ret.begin());
	return ret;		return ret;
	}		}

	const bt_uuid_t Uuid::GetBlueDroid() const {		const bt_uuid_t UUID::GetBlueDroid() const {
	bt_uuid_t ret;		bt_uuid_t ret;
	std::reverse_copy(id_.begin(), id_.end(), ret.uu);		std::reverse_copy(id_.begin(), id_.end(), ret.uu);
	return ret;		return ret;
	}		}

	bool Uuid::operator<(const Uuid& rhs) const {		bool UUID::operator<(const UUID& rhs) const {
	return std::lexicographical_compare(id_.begin(), id_.end(), rhs.id_.begin(),		return std::lexicographical_compare(id_.begin(), id_.end(), rhs.id_.begin(),
	rhs.id_.end());		rhs.id_.end());
	}		}

	bool Uuid::operator==(const Uuid& rhs) const {		bool UUID::operator==(const UUID& rhs) const {
	return std::equal(id_.begin(), id_.end(), rhs.id_.begin());		return std::equal(id_.begin(), id_.end(), rhs.id_.begin());
	}		}