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

Commit d80f7cfb authored by cmanton@google.com's avatar cmanton@google.com Committed by Chris Manton
Browse files

gdx: Device discovery add eir GetShortenedNames 

Bug: 320474533
Bug: 315049108
Test: atest bluetooth_test_gdx_unit
Flag: gdx_device_discovery

Change-Id: I0b9bd64d5e2a1e4b1bc979d681171e3d02abd2a9
parent ac7a2711

system/gd/discovery/device/eir_data.cc

+11 −0
Original line number Original line Diff line number Diff line
@@ -44,6 +44,17 @@ bool EirData::GetCompleteNames(std::vector<std::array<uint8_t, 240>>& names) con 
  return !names.empty();

  return !names.empty();

}

}





bool EirData::GetShortenedNames(std::vector<std::array<uint8_t, 240>>& names) const {

  for (const auto& gap_data : gap_data_) {

    if (gap_data.data_type_ == hci::GapDataType::SHORTENED_LOCAL_NAME) {

      std::array<uint8_t, 240> array;

      std::copy(gap_data.data_.begin(), gap_data.data_.end(), array.begin());

      names.push_back(array);

    }

  }

  return !names.empty();

}



bool EirData::GetUuids16(std::vector<uint16_t>& uuids) const {

bool EirData::GetUuids16(std::vector<uint16_t>& uuids) const {

  for (const auto& gap_data : gap_data_) {

  for (const auto& gap_data : gap_data_) {

    if (gap_data.data_type_ == hci::GapDataType::COMPLETE_LIST_16_BIT_UUIDS) {

    if (gap_data.data_type_ == hci::GapDataType::COMPLETE_LIST_16_BIT_UUIDS) {

system/gd/discovery/device/eir_data.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -31,6 +31,7 @@ class EirData : public DataParser { 
  EirData(const std::vector<uint8_t>& data);

  EirData(const std::vector<uint8_t>& data);





  bool GetCompleteNames(std::vector<std::array<uint8_t, 240>>&) const;

  bool GetCompleteNames(std::vector<std::array<uint8_t, 240>>&) const;

  bool GetShortenedNames(std::vector<std::array<uint8_t, 240>>&) const;





  bool GetUuids16(std::vector<uint16_t>&) const;

  bool GetUuids16(std::vector<uint16_t>&) const;

  bool GetUuidsIncomplete16(std::vector<uint16_t>&) const;

  bool GetUuidsIncomplete16(std::vector<uint16_t>&) const;

system/gd/discovery/device/eir_data_unittest.cc

+58 −72
Original line number Original line Diff line number Diff line
@@ -29,6 +29,7 @@ constexpr uint8_t kPartialUuid16Data[] = { 
    0x2, static_cast<uint8_t>(hci::GapDataType::COMPLETE_LIST_16_BIT_UUIDS), 0x34};

    0x2, static_cast<uint8_t>(hci::GapDataType::COMPLETE_LIST_16_BIT_UUIDS), 0x34};

constexpr uint8_t kOneUuid16Data[] = {

constexpr uint8_t kOneUuid16Data[] = {

    0x3, static_cast<uint8_t>(hci::GapDataType::COMPLETE_LIST_16_BIT_UUIDS), 0x34, 0x12};

    0x3, static_cast<uint8_t>(hci::GapDataType::COMPLETE_LIST_16_BIT_UUIDS), 0x34, 0x12};

constexpr char kAudiMmi9962[] = "Audi_MMI_9962";

}  // namespace

}  // namespace





namespace debug {

namespace debug {
@@ -64,110 +65,95 @@ TEST(EirDataTest, one_uuid16) { 
}

}





TEST(EirDataTest, test_data_packets__data_type) {

TEST(EirDataTest, test_data_packets__data_type) {

  for (const auto& pkt : data_packets) {

  ASSERT_EQ(1U, selected_packets.count("pkt34639"));

  const auto& pkt = selected_packets["pkt34639"];

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  std::vector<hci::GapDataType> gap_data_types = eir_data.GetDataTypes();

  std::vector<hci::GapDataType> gap_data_types = eir_data.GetDataTypes();

    if (!gap_data_types.empty()) {



      LOG_INFO("pkt:");

  ASSERT_EQ(6U, gap_data_types.size());

      for (const auto& type : gap_data_types) {

        LOG_INFO("  Data type:%s", hci::GapDataTypeText(type).c_str());

      }

    }

  }

}

}





TEST(EirDataTest, test_data_packets__complete_name) {

TEST(EirDataTest, test_data_packets__complete_name) {

  for (const auto& pkt : data_packets) {

  ASSERT_EQ(1U, selected_packets.count("pkt34639"));

  const auto& pkt = selected_packets["pkt34639"];

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  std::vector<std::array<uint8_t, kEirSize>> names;

  std::vector<std::array<uint8_t, kEirSize>> names;

    if (eir_data.GetCompleteNames(names)) {

  ASSERT_TRUE(eir_data.GetCompleteNames(names));

      LOG_INFO("Name pkt:");

  ASSERT_EQ(1U, names.size());

      for (const auto& v : names) {

  std::string name(names[0].begin(), names[0].end());

        std::string name(v.begin(), v.end());

  ASSERT_STREQ(kAudiMmi9962, name.c_str());

        LOG_INFO("  Name:%s", name.c_str());

      }

    }

  }

}

}





TEST(EirDataTest, test_data_packets__uuids16) {

TEST(EirDataTest, test_data_packets__uuids16) {

  for (const auto& pkt : data_packets) {

  ASSERT_EQ(1U, selected_packets.count("pkt34639"));

  const auto& pkt = selected_packets["pkt34639"];

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

    std::vector<uint16_t> uuids;

  std::vector<uint16_t> uuids16;

    if (eir_data.GetUuids16(uuids)) {



      LOG_INFO("Uuid pkt:");

  ASSERT_TRUE(eir_data.GetUuids16(uuids16));

      for (const auto& u : uuids) {

  ASSERT_EQ(14U, uuids16.size());

        LOG_INFO("  Uuid:0x%x", u);

  ASSERT_EQ(0x112e, uuids16[0]);

      }

  ASSERT_EQ(0x180a, uuids16[13]);

    }

  }

}

}





TEST(EirDataTest, test_data_packets__uuids16_incomplete) {

TEST(EirDataTest, test_data_packets__uuids16_incomplete) {

  for (const auto& pkt : data_packets) {

  ASSERT_EQ(1U, selected_packets.count("pkt19200"));

  const auto& pkt = selected_packets["pkt19200"];

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

    std::vector<uint16_t> uuids;



    if (eir_data.GetUuidsIncomplete16(uuids)) {

  std::vector<uint16_t> uuids16;

      LOG_INFO("Uuid pkt:");

  ASSERT_TRUE(eir_data.GetUuidsIncomplete16(uuids16));

      for (const auto& u : uuids) {

  ASSERT_EQ(7U, uuids16.size());

        LOG_INFO("  Uuid:0x%x", u);

  ASSERT_EQ(0x110d, uuids16[0]);

      }

  ASSERT_EQ(0x1131, uuids16[6]);

    }

  }

}

}





TEST(EirDataTest, test_data_packets__device_id) {

TEST(EirDataTest, test_data_packets__device_id) {

  for (const auto& pkt : data_packets) {

  for (const auto& pkt : data_packets) {

    const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

    const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

    std::vector<uint8_t> device_ids;

    std::vector<uint8_t> device_ids;

    if (eir_data.GetDeviceId(device_ids)) {

    ASSERT_FALSE(eir_data.GetDeviceId(device_ids));

      LOG_INFO("  device_id count:%llu", (unsigned long long)device_ids.size());

    }

  }

  }

}

}





TEST(EirDataTest, test_data_packets__manufacturer_data) {

TEST(EirDataTest, test_data_packets__manufacturer_data) {

  for (const auto& pkt : data_packets) {

  ASSERT_EQ(1U, selected_packets.count("pkt26171"));

  const auto& pkt = selected_packets["pkt26171"];

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  std::vector<std::vector<uint8_t>> mfr_data;

  std::vector<std::vector<uint8_t>> mfr_data;

    if (eir_data.GetManufacturerSpecificData(mfr_data)) {

  ASSERT_TRUE(eir_data.GetManufacturerSpecificData(mfr_data));

      LOG_INFO("  mfr data count:%llu", (unsigned long long)mfr_data.size());

  ASSERT_EQ(1U, mfr_data.size());

    }

  ASSERT_EQ(0, mfr_data[0][0]);

  }

}

}





TEST(EirDataTest, test_data_packets__security_manager_oob_flags) {

TEST(EirDataTest, test_data_packets__security_manager_oob_flags) {

  for (const auto& pkt : data_packets) {

  ASSERT_EQ(1U, selected_packets.count("pkt26171"));

  const auto& pkt = selected_packets["pkt26171"];

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));



  std::vector<std::vector<uint8_t>> oob_flags;

  std::vector<std::vector<uint8_t>> oob_flags;

    if (eir_data.GetManufacturerSpecificData(oob_flags)) {

  ASSERT_TRUE(eir_data.GetManufacturerSpecificData(oob_flags));

      LOG_INFO("  oob flags count:%llu", (unsigned long long)oob_flags.size());

  ASSERT_EQ(1U, oob_flags.size());

    }

  ASSERT_EQ(0, oob_flags[0][0]);

  }

}

}





TEST(EirDataTest, test_data_packets__service_uuids32) {

TEST(EirDataTest, test_data_packets__service_uuids32) {

  for (const auto& pkt : data_packets) {

  for (const auto& pkt : data_packets) {

    const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

    const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

    std::vector<uint32_t> uuids;

    std::vector<uint32_t> uuids;

    if (eir_data.GetServiceUuuids32(uuids)) {

    ASSERT_FALSE(eir_data.GetServiceUuuids32(uuids));

      for (const auto& uuid : uuids) {

        LOG_INFO("  service uuid:%u", uuid);

      }

    }

  }

  }

}

}





TEST(EirDataTest, test_data_packets__tx_power_level) {

TEST(EirDataTest, test_data_packets__tx_power_level) {

  for (const auto& pkt : data_packets) {

  ASSERT_EQ(1U, selected_packets.count("pkt34639"));

  const auto& pkt = selected_packets["pkt34639"];

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));

  const EirData eir_data(std::vector<uint8_t>(&pkt[kEirOffset], &pkt[kEirOffset] + kEirSize));



  std::vector<int8_t> levels;

  std::vector<int8_t> levels;

    if (eir_data.GetTxPowerLevel(levels)) {

  ASSERT_TRUE(eir_data.GetTxPowerLevel(levels));

      for (const auto& level : levels) {

  ASSERT_EQ(1U, levels.size());

        LOG_INFO("  tx power level:%hhd", level);

  ASSERT_EQ(4, levels[0]);

      }

    }

  }

}

}





TEST(EirDataTest, test_select_packets__pkt34639) {

TEST(EirDataTest, test_select_packets__pkt34639) {

system/gd/discovery/device/eir_test_data_packets.cc

+2 −0
Original line number Original line Diff line number Diff line
@@ -13451,6 +13451,8 @@ static const unsigned char pkt7051[258] = { 
















std::unordered_map<std::string, const unsigned char*> selected_packets = {







std::unordered_map<std::string, const unsigned char*> selected_packets = {











    {"pkt34639", pkt34639},







    {"pkt34639", pkt34639},














    {"pkt19200", pkt19200},














    {"pkt26171", pkt26171},











};







};



























std::vector<const unsigned char*> data_packets = {







std::vector<const unsigned char*> data_packets = {