service: Rename Uuid to UUID
This is more consistent with the ancronym naming convention in the
framework code (e.g. java.util.UUID) and elsewhere in the Bluetooth
daemon.
Change-Id: I3461cf12d563e00ba5e0b0b390bd9ef94e6d7418
diff --git a/service/gatt_server.cpp b/service/gatt_server.cpp
index 5fcda80..b5efebe 100644
--- a/service/gatt_server.cpp
+++ b/service/gatt_server.cpp
@@ -82,7 +82,7 @@
namespace gatt {
struct Characteristic {
- Uuid uuid;
+ UUID uuid;
int blob_section;
std::vector<uint8_t> blob;
@@ -97,12 +97,12 @@
~ServerInternals();
int Initialize();
bt_status_t AddCharacteristic(
- const Uuid& uuid,
+ const UUID& uuid,
int properties,
int permissions);
// 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.
std::unordered_map<int, Characteristic> characteristics;
@@ -112,7 +112,7 @@
ScanResults scan_results;
- Uuid last_write;
+ UUID last_write;
const btgatt_interface_t *gatt;
int server_if;
int client_if;
@@ -231,7 +231,7 @@
} else if (!is_prep) {
// This is a single frame characteristic write.
// 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(),
attr_uuid.size());
if (-1 == status)
@@ -272,7 +272,7 @@
std::lock_guard<std::mutex> lock(g_internal->lock);
// 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();
int status = write(g_internal->pipefd[kPipeWriteEnd],
uuid.data(), uuid.size());
@@ -298,7 +298,7 @@
"%s: status:%d server_if:%d service_handle:%d char_handle:%d", __func__,
status, server_if, srvc_handle, char_handle);
- bluetooth::Uuid id(*uuid);
+ bluetooth::UUID id(*uuid);
std::lock_guard<std::mutex> lock(g_internal->lock);
@@ -508,7 +508,7 @@
}
bt_status_t ServerInternals::AddCharacteristic(
- const Uuid& uuid,
+ const UUID& uuid,
int properties,
int permissions) {
bt_uuid_t c_uuid = uuid.GetBlueDroid();
@@ -538,7 +538,7 @@
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);
if (!internal_) {
LOG_ERROR(LOG_TAG, "Error creating internals");
@@ -573,7 +573,7 @@
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>& manufacturer_data,
bool transmit_name) {
@@ -581,7 +581,7 @@
auto mutable_manufacturer_data = manufacturer_data;
auto mutable_service_data = service_data;
- for (const Uuid &id : ids) {
+ for (const UUID &id : ids) {
const auto le_id = id.GetFullLittleEndian();
id_data.insert(id_data.end(), le_id.begin(), le_id.end());
}
@@ -607,7 +607,7 @@
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>& manufacturer_data,
bool transmit_name) {
@@ -615,7 +615,7 @@
auto mutable_manufacturer_data = manufacturer_data;
auto mutable_service_data = service_data;
- for (const Uuid &id : ids) {
+ for (const UUID &id : ids) {
const auto le_id = id.GetFullLittleEndian();
id_data.insert(id_data.end(), le_id.begin(), le_id.end());
}
@@ -642,7 +642,7 @@
}
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);
bt_status_t btstat = internal_->AddCharacteristic(
id, properties, permissions);
@@ -657,7 +657,7 @@
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) {
std::unique_lock<std::mutex> lock(internal_->lock);
@@ -746,7 +746,7 @@
return true;
}
-bool Server::SetCharacteristicValue(const Uuid &id,
+bool Server::SetCharacteristicValue(const UUID &id,
const std::vector<uint8_t> &value) {
std::lock_guard<std::mutex> lock(internal_->lock);
const int attribute_id = internal_->uuid_to_attribute[id];
@@ -769,7 +769,7 @@
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);
const int attribute_id = internal_->uuid_to_attribute[id];
*value = internal_->characteristics[attribute_id].blob;
diff --git a/service/gatt_server.h b/service/gatt_server.h
index e71abff..ff41760 100644
--- a/service/gatt_server.h
+++ b/service/gatt_server.h
@@ -65,34 +65,34 @@
// Register GATT interface, initialize internal state,
// and open a pipe for characteristic write notification.
- bool Initialize(const Uuid& service_id, int* gatt_pipe);
+ bool Initialize(const UUID& service_id, int* gatt_pipe);
// Control the content of service advertisement.
- bool SetAdvertisement(const std::vector<Uuid>& ids,
+ bool SetAdvertisement(const std::vector<UUID>& ids,
const std::vector<uint8_t>& service_data,
const std::vector<uint8_t>& manufacturer_data,
bool transmit_name);
// Control the content of service scan response.
- bool SetScanResponse(const std::vector<Uuid>& ids,
+ bool SetScanResponse(const std::vector<UUID>& ids,
const std::vector<uint8_t>& service_data,
const std::vector<uint8_t>& manufacturer_data,
bool transmit_name);
// Add an ordinary characteristic for reading and/or writing.
- bool AddCharacteristic(const Uuid &id, int properties, int permissions);
+ bool AddCharacteristic(const UUID &id, int properties, int permissions);
// Add a special 'blob' characteristic with a corresponding control
// attribute to manipulate which part of the blob the attribute represents.
- bool AddBlob(const Uuid &id, const Uuid &control_id, int properties,
+ bool AddBlob(const UUID &id, const UUID &control_id, int properties,
int permissions);
// Put a new value into a characeteristic.
// It will be read from a client starting at the next 0-offset read.
- bool SetCharacteristicValue(const Uuid &id, const std::vector<uint8_t> &value);
+ bool SetCharacteristicValue(const UUID &id, const std::vector<uint8_t> &value);
// Get the current value of a characteristic.
- bool GetCharacteristicValue(const Uuid &id, std::vector<uint8_t> *value);
+ bool GetCharacteristicValue(const UUID &id, std::vector<uint8_t> *value);
// Start this service. Activate advertisements, allow connections.
// Characteristics should all be created before this.
diff --git a/service/ipc/unix_ipc_host.cpp b/service/ipc/unix_ipc_host.cpp
index b7a64da..2f801d4 100644
--- a/service/ipc/unix_ipc_host.cpp
+++ b/service/ipc/unix_ipc_host.cpp
@@ -39,7 +39,7 @@
#include "service/uuid.h"
using bluetooth::Adapter;
-using bluetooth::Uuid;
+using bluetooth::UUID;
using namespace bluetooth::gatt;
@@ -115,7 +115,7 @@
int gattfd;
bool status = gatt_servers_[service_uuid]->Initialize(
- Uuid(service_uuid), &gattfd);
+ UUID(service_uuid), &gattfd);
if (!status) {
LOG_ERROR(LOG_TAG, "Failed to initialize bluetooth");
return false;
@@ -161,10 +161,10 @@
if (control_uuid.empty()) {
gatt_servers_[service_uuid]->AddCharacteristic(
- Uuid(characteristic_uuid), properties_mask, permissions_mask);
+ UUID(characteristic_uuid), properties_mask, permissions_mask);
} else {
- gatt_servers_[service_uuid]->AddBlob(Uuid(characteristic_uuid),
- Uuid(control_uuid), properties_mask,
+ gatt_servers_[service_uuid]->AddBlob(UUID(characteristic_uuid),
+ UUID(control_uuid), properties_mask,
permissions_mask);
}
return true;
@@ -176,7 +176,7 @@
std::string decoded_data;
base::Base64Decode(value, &decoded_data);
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);
return true;
}
@@ -192,8 +192,8 @@
std::vector<std::string> advertise_uuid_tokens;
base::SplitString(advertise_uuids, '.', &advertise_uuid_tokens);
- // string -> vector<Uuid>
- std::vector<Uuid> ids;
+ // string -> vector<UUID>
+ std::vector<UUID> ids;
for (const auto& uuid_token : advertise_uuid_tokens)
ids.emplace_back(uuid_token);
@@ -220,8 +220,8 @@
std::vector<std::string> scan_response_uuid_tokens;
base::SplitString(scan_response_uuids, '.', &scan_response_uuid_tokens);
- // string -> vector<Uuid>
- std::vector<Uuid> ids;
+ // string -> vector<UUID>
+ std::vector<UUID> ids;
for (const auto& uuid_token : scan_response_uuid_tokens)
ids.emplace_back(uuid_token);
@@ -307,7 +307,7 @@
}
bool UnixIPCHost::OnGattWrite() {
- Uuid::Uuid128Bit id;
+ UUID::UUID128Bit id;
int r = read(pfds_[kFdGatt].fd, id.data(), id.size());
if (r != id.size()) {
LOG_ERROR(LOG_TAG, "Error reading GATT attribute ID");
@@ -317,7 +317,7 @@
std::vector<uint8_t> value;
// TODO(icoolidge): Generalize this for multiple clients.
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());
std::string encoded_value;
base::Base64Encode(value_string, &encoded_value);
diff --git a/service/test/uuid_unittest.cpp b/service/test/uuid_unittest.cpp
index 6e69a48..6f828c9 100644
--- a/service/test/uuid_unittest.cpp
+++ b/service/test/uuid_unittest.cpp
@@ -25,99 +25,99 @@
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,
0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb, }
};
} // namespace
-// Verify that an uninitialized Uuid is equal
+// Verify that an uninitialized UUID is equal
// To the BT SIG Base UUID.
-TEST(UuidTest, DefaultUuid) {
- Uuid uuid;
- ASSERT_TRUE(uuid.GetFullBigEndian() == kBtSigBaseUuid);
+TEST(UUIDTest, DefaultUUID) {
+ UUID uuid;
+ ASSERT_TRUE(uuid.GetFullBigEndian() == kBtSigBaseUUID);
}
// Verify that we initialize a 16-bit UUID in a
// way consistent with how we read it.
-TEST(UuidTest, Init16Bit) {
- auto my_uuid_16 = kBtSigBaseUuid;
+TEST(UUIDTest, Init16Bit) {
+ auto my_uuid_16 = kBtSigBaseUUID;
my_uuid_16[2] = 0xde;
my_uuid_16[3] = 0xad;
- Uuid uuid(Uuid::Uuid16Bit({{ 0xde, 0xad }}));
+ UUID uuid(UUID::UUID16Bit({{ 0xde, 0xad }}));
ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);
}
// Verify that we initialize a 16-bit UUID in a
// way consistent with how we read it.
-TEST(UuidTest, Init16BitString) {
- auto my_uuid_16 = kBtSigBaseUuid;
+TEST(UUIDTest, Init16BitString) {
+ auto my_uuid_16 = kBtSigBaseUUID;
my_uuid_16[2] = 0xde;
my_uuid_16[3] = 0xad;
- Uuid uuid("dead");
+ UUID uuid("dead");
ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_16);
}
// Verify that we initialize a 32-bit UUID in a
// way consistent with how we read it.
-TEST(UuidTest, Init32Bit) {
- auto my_uuid_32 = kBtSigBaseUuid;
+TEST(UUIDTest, Init32Bit) {
+ auto my_uuid_32 = kBtSigBaseUUID;
my_uuid_32[0] = 0xde;
my_uuid_32[1] = 0xad;
my_uuid_32[2] = 0xbe;
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);
}
// Verify correct reading of a 32-bit UUID initialized from string.
-TEST(UuidTest, Init32BitString) {
- auto my_uuid_32 = kBtSigBaseUuid;
+TEST(UUIDTest, Init32BitString) {
+ auto my_uuid_32 = kBtSigBaseUUID;
my_uuid_32[0] = 0xde;
my_uuid_32[1] = 0xad;
my_uuid_32[2] = 0xbe;
my_uuid_32[3] = 0xef;
- Uuid uuid("deadbeef");
+ UUID uuid("deadbeef");
ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_32);
}
// Verify that we initialize a 128-bit UUID in a
// way consistent with how we read it.
-TEST(UuidTest, Init128Bit) {
- auto my_uuid_128 = kBtSigBaseUuid;
+TEST(UUIDTest, Init128Bit) {
+ auto my_uuid_128 = kBtSigBaseUUID;
for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
my_uuid_128[i] = i;
}
- Uuid uuid(my_uuid_128);
+ UUID uuid(my_uuid_128);
ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);
}
// Verify that we initialize a 128-bit UUID in a
// way consistent with how we read it as LE.
-TEST(UuidTest, Init128BitLittleEndian) {
- auto my_uuid_128 = kBtSigBaseUuid;
+TEST(UUIDTest, Init128BitLittleEndian) {
+ auto my_uuid_128 = kBtSigBaseUUID;
for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++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());
ASSERT_TRUE(uuid.GetFullLittleEndian() == my_uuid_128);
}
// Verify that we initialize a 128-bit UUID in a
// way consistent with how we read it.
-TEST(UuidTest, Init128BitString) {
- auto my_uuid_128 = kBtSigBaseUuid;
+TEST(UUIDTest, Init128BitString) {
+ auto my_uuid_128 = kBtSigBaseUUID;
for (int i = 0; i < static_cast<int>(my_uuid_128.size()); ++i) {
my_uuid_128[i] = i;
}
std::string uuid_text("000102030405060708090A0B0C0D0E0F");
ASSERT_TRUE(uuid_text.size() == (16 * 2));
- Uuid uuid(uuid_text);
+ UUID uuid(uuid_text);
ASSERT_TRUE(uuid.GetFullBigEndian() == my_uuid_128);
}
diff --git a/service/uuid.cpp b/service/uuid.cpp
index c48ba5e..74009c4 100644
--- a/service/uuid.cpp
+++ b/service/uuid.cpp
@@ -13,7 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
-#include "uuid.h"
+
+#include "service/uuid.h"
#include <algorithm>
#include <array>
@@ -22,17 +23,17 @@
namespace bluetooth {
-void Uuid::InitializeDefault() {
+void UUID::InitializeDefault() {
// Initialize to base bluetooth UUID.
id_ = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb}};
}
-Uuid::Uuid() {
+UUID::UUID() {
InitializeDefault();
}
-Uuid::Uuid(const std::string& uuid) {
+UUID::UUID(const std::string& uuid) {
InitializeDefault();
const int start_index = uuid.size() == 4 ? 2 : 0;
const size_t copy_size = std::min(id_.size(), uuid.size() / 2);
@@ -42,44 +43,44 @@
}
}
-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());
}
-Uuid::Uuid(const Uuid::Uuid16Bit& uuid) {
+UUID::UUID(const UUID::UUID16Bit& uuid) {
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();
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_;
}
-const Uuid::Uuid128Bit Uuid::GetFullLittleEndian() const {
- Uuid::Uuid128Bit ret;
+const UUID::UUID128Bit UUID::GetFullLittleEndian() const {
+ UUID::UUID128Bit ret;
std::reverse_copy(id_.begin(), id_.end(), ret.begin());
return ret;
}
-const bt_uuid_t Uuid::GetBlueDroid() const {
+const bt_uuid_t UUID::GetBlueDroid() const {
bt_uuid_t ret;
std::reverse_copy(id_.begin(), id_.end(), ret.uu);
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(),
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());
}
diff --git a/service/uuid.h b/service/uuid.h
index 0226ef6..929294f 100644
--- a/service/uuid.h
+++ b/service/uuid.h
@@ -13,6 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
+
#pragma once
#include <array>
@@ -22,48 +23,48 @@
namespace bluetooth {
-class Uuid {
+class UUID {
public:
enum Type {
- kUuid128Octets = 16,
- kUuid32Octets = 4,
- kUuid16Octets = 2,
+ kUUID128Octets = 16,
+ kUUID32Octets = 4,
+ kUUID16Octets = 2,
};
- typedef std::array<uint8_t, Uuid::kUuid16Octets> Uuid16Bit;
- typedef std::array<uint8_t, Uuid::kUuid32Octets> Uuid32Bit;
- typedef std::array<uint8_t, Uuid::kUuid128Octets> Uuid128Bit;
+ typedef std::array<uint8_t, UUID::kUUID16Octets> UUID16Bit;
+ typedef std::array<uint8_t, UUID::kUUID32Octets> UUID32Bit;
+ typedef std::array<uint8_t, UUID::kUUID128Octets> UUID128Bit;
// Construct a Bluetooth 'base' UUID.
- Uuid();
+ UUID();
// BlueDroid constructor.
- explicit Uuid(const bt_uuid_t& uuid);
+ explicit UUID(const bt_uuid_t& uuid);
// String constructor. Only hex ASCII accepted.
- explicit Uuid(const std::string& uuid);
+ explicit UUID(const std::string& uuid);
// std::array variants constructors.
- explicit Uuid(const Uuid::Uuid16Bit& uuid);
- explicit Uuid(const Uuid::Uuid32Bit& uuid);
- explicit Uuid(const Uuid::Uuid128Bit& uuid);
+ explicit UUID(const UUID::UUID16Bit& uuid);
+ explicit UUID(const UUID::UUID32Bit& uuid);
+ explicit UUID(const UUID::UUID128Bit& uuid);
// Provide the full network-byte-ordered blob.
- const Uuid128Bit GetFullBigEndian() const;
+ const UUID128Bit GetFullBigEndian() const;
// Provide blob in Little endian (BlueDroid expects this).
- const Uuid128Bit GetFullLittleEndian() const;
+ const UUID128Bit GetFullLittleEndian() const;
// Helper for bluedroid LE type.
const bt_uuid_t GetBlueDroid() const;
- bool operator<(const Uuid& rhs) const;
- bool operator==(const Uuid& rhs) const;
+ bool operator<(const UUID& rhs) const;
+ bool operator==(const UUID& rhs) const;
private:
void InitializeDefault();
// Network-byte-ordered ID.
- Uuid128Bit id_;
+ UUID128Bit id_;
};
} // namespace bluetooth