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

Commit 26ccadfa authored by Rahul Arya's avatar Rahul Arya Committed by Cherrypicker Worker
Browse files

Use dedicated enum for Advertiser Address Type 

OwnAddressType is not appropriate since it includes cases that are
impossible in our stack, and merges RPA + NRPA together.

No behavioral changes.

Test: unit
Bug: 268112598
(cherry picked from https://android-review.googlesource.com/q/commit:80c922dc1e33b673af3ff43c0a9928f600c69782)
Merged-In: I9139c5e63cc9d34ed21f0005336e1517c80628f2
Change-Id: I9139c5e63cc9d34ed21f0005336e1517c80628f2
Bug:279962122
parent 38f1c6fd

system/gd/hci/facade/le_advertising_manager_facade.cc

+5 −1
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ using ::grpc::Status; 


using ::blueberry::facade::BluetoothAddress;

using ::blueberry::facade::BluetoothAddressTypeEnum;

using ::blueberry::facade::BluetoothOwnAddressTypeEnum;

using ::blueberry::facade::hci::AdvertisingConfig;

using ::blueberry::facade::hci::ExtendedAdvertisingConfig;

using ::blueberry::facade::hci::GapDataMsg;
@@ -79,7 +80,10 @@ bool AdvertisingConfigFromProto(const AdvertisingConfig& config_proto, hci::Exte 


  config->advertising_type = static_cast<hci::AdvertisingType>(config_proto.advertising_type());



  config->own_address_type = static_cast<::bluetooth::hci::OwnAddressType>(config_proto.own_address_type());

  config->requested_advertiser_address_type =

      config_proto.own_address_type() == BluetoothOwnAddressTypeEnum::USE_PUBLIC_DEVICE_ADDRESS

          ? AdvertiserAddressType::PUBLIC

          : AdvertiserAddressType::RESOLVABLE_RANDOM;



  config->peer_address_type = static_cast<::bluetooth::hci::PeerAddressType>(config_proto.peer_address_type());

system/gd/hci/le_address_manager.h

+8 −6
Original line number Diff line number Diff line
@@ -71,15 +71,15 @@ class LeAddressManager { 
      crypto_toolbox::Octet16 rotation_irk,

      std::chrono::milliseconds minimum_rotation_time,

      std::chrono::milliseconds maximum_rotation_time);

  virtual AddressPolicy GetAddressPolicy();

  AddressPolicy GetAddressPolicy();

  virtual void AckPause(LeAddressManagerCallback* callback);

  virtual void AckResume(LeAddressManagerCallback* callback);

  virtual AddressPolicy Register(LeAddressManagerCallback* callback);

  virtual void Unregister(LeAddressManagerCallback* callback);

  virtual bool UnregisterSync(

      LeAddressManagerCallback* callback, std::chrono::milliseconds timeout = kUnregisterSyncTimeoutInMs);

  virtual AddressWithType GetCurrentAddress();  // What was set in SetRandomAddress()

  virtual AddressWithType GetAnotherAddress();  // A new random address without rotating.

  AddressWithType GetCurrentAddress();  // What was set in SetRandomAddress()

  AddressWithType GetAnotherAddress();  // A new random address without rotating.



  uint8_t GetFilterAcceptListSize();

  uint8_t GetResolvingListSize();
@@ -101,6 +101,11 @@ class LeAddressManager { 
    return cached_commands_.size();

  }



 protected:

  AddressPolicy address_policy_ = AddressPolicy::POLICY_NOT_SET;

  std::chrono::milliseconds minimum_rotation_time_;

  std::chrono::milliseconds maximum_rotation_time_;



 private:

  enum ClientState {

    WAITING_FOR_PAUSE,
@@ -163,14 +168,11 @@ class LeAddressManager { 
  os::Handler* handler_;

  std::map<LeAddressManagerCallback*, ClientState> registered_clients_;



  AddressPolicy address_policy_ = AddressPolicy::POLICY_NOT_SET;

  AddressWithType le_address_;

  AddressWithType cached_address_;

  Address public_address_;

  std::unique_ptr<os::Alarm> address_rotation_alarm_;

  crypto_toolbox::Octet16 rotation_irk_;

  std::chrono::milliseconds minimum_rotation_time_;

  std::chrono::milliseconds maximum_rotation_time_;

  uint8_t connect_list_size_;

  uint8_t resolving_list_size_;

  std::queue<Command> cached_commands_;

system/gd/hci/le_advertising_manager.cc

+31 −30
Original line number Diff line number Diff line
@@ -330,12 +330,6 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 


    switch (advertising_api_type_) {

      case (AdvertisingApiType::LEGACY): {

        set_parameters(id, config);

        if (config.advertising_type == AdvertisingType::ADV_IND ||

            config.advertising_type == AdvertisingType::ADV_NONCONN_IND) {

          set_data(id, true, config.scan_response);

        }

        set_data(id, false, config.advertisement);

        auto address_policy = le_address_manager_->GetAddressPolicy();

        if (address_policy == LeAddressManager::AddressPolicy::USE_NON_RESOLVABLE_ADDRESS ||

            address_policy == LeAddressManager::AddressPolicy::USE_RESOLVABLE_ADDRESS) {
@@ -343,6 +337,12 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
        } else {

          advertising_sets_[id].current_address = le_address_manager_->GetCurrentAddress();

        }

        set_parameters(id, config);

        if (config.advertising_type == AdvertisingType::ADV_IND ||

            config.advertising_type == AdvertisingType::ADV_NONCONN_IND) {

          set_data(id, true, config.scan_response);

        }

        set_data(id, false, config.advertisement);

        if (!paused) {

          enable_advertiser(id, true, 0, 0);

        } else {
@@ -430,21 +430,22 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
    advertising_sets_[id].max_extended_advertising_events = max_ext_adv_events;

    advertising_sets_[id].handler = handler;



    set_parameters(id, config);



    auto address_policy = le_address_manager_->GetAddressPolicy();

    switch (config.own_address_type) {

      case OwnAddressType::RANDOM_DEVICE_ADDRESS:

    switch (config.requested_advertiser_address_type) {

      case AdvertiserAddressType::RESOLVABLE_RANDOM:

        if (address_policy == LeAddressManager::AddressPolicy::USE_NON_RESOLVABLE_ADDRESS ||

            address_policy == LeAddressManager::AddressPolicy::USE_RESOLVABLE_ADDRESS) {

          AddressWithType address_with_type = le_address_manager_->GetAnotherAddress();

          advertising_sets_[id].current_address = le_address_manager_->GetAnotherAddress();

          set_parameters(id, config);

          le_advertising_interface_->EnqueueCommand(

              hci::LeSetAdvertisingSetRandomAddressBuilder::Create(id, address_with_type.GetAddress()),

              hci::LeSetAdvertisingSetRandomAddressBuilder::Create(

                  id, advertising_sets_[id].current_address.GetAddress()),

              module_handler_->BindOnceOn(

                  this,

                  &impl::on_set_advertising_set_random_address_complete<LeSetAdvertisingSetRandomAddressCompleteView>,

                  &impl::on_set_advertising_set_random_address_complete<

                      LeSetAdvertisingSetRandomAddressCompleteView>,

                  id,

                  address_with_type));

                  advertising_sets_[id].current_address));



          // start timer for random address

          advertising_sets_[id].address_rotation_alarm = std::make_unique<os::Alarm>(module_handler_);
@@ -457,15 +458,17 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
              hci::LeSetAdvertisingSetRandomAddressBuilder::Create(

                  id, advertising_sets_[id].current_address.GetAddress()),

              module_handler_->BindOnce(impl::check_status<LeSetAdvertisingSetRandomAddressCompleteView>));

          set_parameters(id, config);

        }

        break;

      case OwnAddressType::PUBLIC_DEVICE_ADDRESS:

      case AdvertiserAddressType::PUBLIC:

        advertising_sets_[id].current_address =

            AddressWithType(controller_->GetMacAddress(), AddressType::PUBLIC_DEVICE_ADDRESS);

        set_parameters(id, config);

        break;

      default:

        // For resolvable address types, set the Peer address and type, and the controller generates the address.

        LOG_ALWAYS_FATAL("Unsupported Advertising Type %s", OwnAddressTypeText(config.own_address_type).c_str());

        LOG_ALWAYS_FATAL(

            "Unsupported Advertising Type %d", config.requested_advertiser_address_type);

    }

    if (config.advertising_type == AdvertisingType::ADV_IND ||

        config.advertising_type == AdvertisingType::ADV_NONCONN_IND) {
@@ -598,6 +601,11 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
    advertising_sets_[advertiser_id].tx_power = config.tx_power;

    advertising_sets_[advertiser_id].directed = config.directed;



    // note: does not necessarily match config.requested_advertiser_address_type, since we will

    // ignore the config but instead always use PUBLIC if the device does not support privacy

    auto own_address_type = static_cast<OwnAddressType>(

        advertising_sets_[advertiser_id].current_address.GetAddressType());



    switch (advertising_api_type_) {

      case (AdvertisingApiType::LEGACY): {

        le_advertising_interface_->EnqueueCommand(
@@ -605,17 +613,17 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
                config.interval_min,

                config.interval_max,

                config.advertising_type,

                config.own_address_type,

                own_address_type,

                config.peer_address_type,

                config.peer_address,

                config.channel_map,

                config.filter_policy),

            module_handler_->BindOnceOn(

                this, &impl::check_status_with_id<LeSetAdvertisingParametersCompleteView>, advertiser_id));

                this,

                &impl::check_status_with_id<LeSetAdvertisingParametersCompleteView>,

                advertiser_id));

      } break;

      case (AdvertisingApiType::ANDROID_HCI): {

        auto own_address_type =

            static_cast<OwnAddressType>(advertising_sets_[advertiser_id].current_address.GetAddressType());

        le_advertising_interface_->EnqueueCommand(

            hci::LeMultiAdvtParamBuilder::Create(

                config.interval_min,
@@ -659,7 +667,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
                  config.interval_min,

                  config.interval_max,

                  config.channel_map,

                  config.own_address_type,

                  own_address_type,

                  config.peer_address_type,

                  config.peer_address,

                  config.filter_policy,
@@ -688,7 +696,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
                  config.interval_min,

                  config.interval_max,

                  config.channel_map,

                  config.own_address_type,

                  own_address_type,

                  config.peer_address_type,

                  config.peer_address,

                  config.filter_policy,
@@ -1495,13 +1503,6 @@ AdvertiserId LeAdvertisingManager::create_advertiser( 
    const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

    os::Handler* handler) {

  if (config.peer_address == Address::kEmpty) {

    if (config.own_address_type == hci::OwnAddressType::RESOLVABLE_OR_PUBLIC_ADDRESS ||

        config.own_address_type == hci::OwnAddressType::RESOLVABLE_OR_RANDOM_ADDRESS) {

      LOG_WARN("Peer address can not be empty");

      CallOn(

          pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

      return kInvalidId;

    }

    if (config.advertising_type == hci::AdvertisingType::ADV_DIRECT_IND_HIGH ||

        config.advertising_type == hci::AdvertisingType::ADV_DIRECT_IND_LOW) {

      LOG_WARN("Peer address can not be empty for directed advertising");

system/gd/hci/le_advertising_manager.h

+6 −1
Original line number Diff line number Diff line
@@ -33,6 +33,11 @@ class PeriodicAdvertisingParameters { 
  enum AdvertisingProperty { INCLUDE_TX_POWER = 0x06 };

};



enum class AdvertiserAddressType {

  PUBLIC,

  RESOLVABLE_RANDOM,

};



class AdvertisingConfig {

 public:

  std::vector<GapData> advertisement;
@@ -40,7 +45,7 @@ class AdvertisingConfig { 
  uint16_t interval_min;

  uint16_t interval_max;

  AdvertisingType advertising_type;

  OwnAddressType own_address_type;

  AdvertiserAddressType requested_advertiser_address_type;

  PeerAddressType peer_address_type;

  Address peer_address;

  uint8_t channel_map;

system/gd/hci/le_advertising_manager_test.cc

+45 −31
Original line number Diff line number Diff line
@@ -94,7 +94,12 @@ class TestLeAddressManager : public LeAddressManager { 
      Address public_address,

      uint8_t connect_list_size,

      uint8_t resolving_list_size)

      : LeAddressManager(enqueue_command, handler, public_address, connect_list_size, resolving_list_size) {}

      : LeAddressManager(

            enqueue_command, handler, public_address, connect_list_size, resolving_list_size) {

    address_policy_ = AddressPolicy::USE_STATIC_ADDRESS;

    minimum_rotation_time_ = 0ms;

    maximum_rotation_time_ = 100ms;

  }



  AddressPolicy Register(LeAddressManagerCallback* callback) override {

    client_ = callback;
@@ -117,29 +122,10 @@ class TestLeAddressManager : public LeAddressManager { 
    test_client_state_ = RESUMED;

  }



  AddressPolicy GetAddressPolicy() override {

    return address_policy_;

  }



  void SetAddressPolicy(AddressPolicy address_policy) {

    address_policy_ = address_policy;

  }



  AddressWithType GetAnotherAddress() override {

    hci::Address address;

    Address::FromString("05:04:03:02:01:00", address);

    auto random_address = AddressWithType(address, AddressType::RANDOM_DEVICE_ADDRESS);

    return random_address;

  }



  AddressWithType GetCurrentAddress() override {

    hci::Address address;

    Address::FromString("05:04:03:02:01:00", address);

    auto random_address = AddressWithType(address, AddressType::RANDOM_DEVICE_ADDRESS);

    return random_address;

  }



  AddressPolicy address_policy_ = AddressPolicy::USE_STATIC_ADDRESS;

  LeAddressManagerCallback* client_;

  bool ignore_unregister_for_testing = false;

  enum TestClientState {
@@ -259,7 +245,7 @@ class LeAdvertisingAPITest : public LeAdvertisingManagerTest { 
    // start advertising set

    ExtendedAdvertisingConfig advertising_config{};

    advertising_config.advertising_type = AdvertisingType::ADV_IND;

    advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

    advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

    std::vector<GapData> gap_data{};

    GapData data_item{};

    data_item.data_type_ = GapDataType::FLAGS;
@@ -316,7 +302,7 @@ class LeAndroidHciAdvertisingAPITest : public LeAndroidHciAdvertisingManagerTest 


    ExtendedAdvertisingConfig advertising_config{};

    advertising_config.advertising_type = AdvertisingType::ADV_IND;

    advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

    advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

    std::vector<GapData> gap_data{};

    GapData data_item{};

    data_item.data_type_ = GapDataType::FLAGS;
@@ -361,7 +347,7 @@ class LeAndroidHciAdvertisingAPIPublicAddressTest : public LeAndroidHciAdvertisi 


    ExtendedAdvertisingConfig advertising_config{};

    advertising_config.advertising_type = AdvertisingType::ADV_IND;

    advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

    advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

    std::vector<GapData> gap_data{};

    GapData data_item{};

    data_item.data_type_ = GapDataType::FLAGS;
@@ -416,7 +402,7 @@ class LeExtendedAdvertisingAPITest : public LeExtendedAdvertisingManagerTest { 
    // start advertising set

    ExtendedAdvertisingConfig advertising_config{};

    advertising_config.advertising_type = AdvertisingType::ADV_IND;

    advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

    advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

    std::vector<GapData> gap_data{};

    GapData data_item{};

    data_item.data_type_ = GapDataType::FLAGS;
@@ -468,7 +454,7 @@ TEST_F(LeExtendedAdvertisingManagerTest, startup_teardown) {} 
TEST_F(LeAdvertisingManagerTest, create_advertiser_test) {

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::FLAGS;
@@ -514,7 +500,7 @@ TEST_F(LeAdvertisingManagerTest, create_advertiser_test) { 
TEST_F(LeAndroidHciAdvertisingManagerTest, create_advertiser_test) {

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::FLAGS;
@@ -556,7 +542,7 @@ TEST_F(LeAndroidHciAdvertisingManagerTest, create_advertiser_test) { 
TEST_F(LeExtendedAdvertisingManagerTest, create_advertiser_test) {

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::FLAGS;
@@ -609,7 +595,7 @@ TEST_F(LeExtendedAdvertisingManagerTest, ignore_on_pause_on_resume_after_unregis 
  // Register LeAddressManager vai ExtendedCreateAdvertiser

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::FLAGS;
@@ -675,7 +661,7 @@ TEST_F(LeExtendedAdvertisingAPITest, startup_teardown) {} 
TEST_F(LeAdvertisingAPITest, set_parameter) {

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
@@ -694,7 +680,7 @@ TEST_F(LeAdvertisingAPITest, set_parameter) { 
TEST_F(LeAndroidHciAdvertisingAPITest, set_parameter) {

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
@@ -716,7 +702,7 @@ TEST_F(LeAndroidHciAdvertisingAPITest, set_parameter) { 
TEST_F(LeExtendedAdvertisingAPITest, set_parameter) {

  ExtendedAdvertisingConfig advertising_config{};

  advertising_config.advertising_type = AdvertisingType::ADV_IND;

  advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;

  advertising_config.requested_advertiser_address_type = AdvertiserAddressType::PUBLIC;

  std::vector<GapData> gap_data{};

  GapData data_item{};

  data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
@@ -1258,6 +1244,34 @@ TEST_F(LeExtendedAdvertisingAPITest, no_callbacks_on_resume) { 
  sync_client_handler();

}



TEST_F(LeExtendedAdvertisingManagerTest, use_rpa) {

  // arrange: use RANDOM address policy

  test_acl_manager_->SetAddressPolicy(LeAddressManager::AddressPolicy::USE_RESOLVABLE_ADDRESS);



  // act: start advertising set with RPA

  le_advertising_manager_->ExtendedCreateAdvertiser(

      0x00,

      AdvertisingConfig{

          .requested_advertiser_address_type = AdvertiserAddressType::RESOLVABLE_RANDOM,

          .channel_map = 1,

      },

      scan_callback,

      set_terminated_callback,

      0,

      0,

      client_handler_);

  auto command = LeAdvertisingCommandView::Create(test_hci_layer_->GetCommand());



  // assert

  ASSERT_TRUE(command.IsValid());

  EXPECT_EQ(command.GetOpCode(), OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS);



  auto set_parameters_command =

      LeSetExtendedAdvertisingParametersView::Create(LeAdvertisingCommandView::Create(command));

  ASSERT_TRUE(set_parameters_command.IsValid());

  EXPECT_EQ(set_parameters_command.GetOwnAddressType(), OwnAddressType::RANDOM_DEVICE_ADDRESS);

}



}  // namespace

}  // namespace hci

}  // namespace bluetooth