Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6d443336 authored by Arman Uguray's avatar Arman Uguray
Browse files

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
parent 6a21a81f

system/service/gatt_server.cpp

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



struct Characteristic {

  Uuid uuid;

  UUID uuid;

  int blob_section;

  std::vector<uint8_t> blob;
@@ -97,12 +97,12 @@ struct ServerInternals { 
  ~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 @@ struct ServerInternals { 


  ScanResults scan_results;



  Uuid last_write;

  UUID last_write;

  const btgatt_interface_t *gatt;

  int server_if;

  int client_if;
@@ -231,7 +231,7 @@ void RequestWriteCallback(int conn_id, int trans_id, bt_bdaddr_t *bda, 
  } 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 @@ void RequestExecWriteCallback(int conn_id, int trans_id, bt_bdaddr_t *bda, 


  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 @@ void CharacteristicAddedCallback(int status, int server_if, bt_uuid_t *uuid, 
      "%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 @@ int ServerInternals::Initialize() { 
}



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() : internal_(nullptr) {} 


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 @@ bool Server::Initialize(const Uuid& service_id, int* gatt_pipe) { 
  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 @@ bool Server::SetAdvertisement(const std::vector<Uuid>& ids, 
  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 @@ bool Server::SetAdvertisement(const std::vector<Uuid>& ids, 
  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 @@ bool Server::SetScanResponse(const std::vector<Uuid>& ids, 
  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::SetScanResponse(const std::vector<Uuid>& ids, 
}



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 @@ bool Server::AddCharacteristic( 
  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 @@ bool Server::GetScanResults(ScanResults *results) { 
  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 @@ bool Server::SetCharacteristicValue(const Uuid &id, 
  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;

system/service/gatt_server.h

+7 −7
Original line number Diff line number Diff line
@@ -65,34 +65,34 @@ class Server { 


  // 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.

system/service/ipc/unix_ipc_host.cpp

+12 −12
Original line number Diff line number Diff line
@@ -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 @@ bool UnixIPCHost::OnCreateService(const std::string& service_uuid) { 


  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 @@ bool UnixIPCHost::OnAddCharacteristic(const std::string& service_uuid, 


  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 @@ bool UnixIPCHost::OnSetCharacteristicValue(const std::string& service_uuid, 
  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 @@ bool UnixIPCHost::OnSetAdvertisement(const std::string& service_uuid, 
  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 @@ bool UnixIPCHost::OnSetScanResponse(const std::string& service_uuid, 
  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::OnMessage() { 
}



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 @@ bool UnixIPCHost::OnGattWrite() { 
  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);

system/service/test/uuid_unittest.cpp

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


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);

}

system/service/uuid.cpp

+16 −15
Original line number Diff line number Diff line
@@ -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 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());

}



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());

}