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

Commit 8a74e548 authored by Chienyuan's avatar Chienyuan
Browse files

gd HCI: Only register LeAddressRotator when advertising/scanning 

Bug: 152348535
Tag: #gd-refactor
Test: gd/cert/run --host
Test: atest bluetooth_test_gd
Change-Id: I20a479c6f987f93e349e0214f0c1fb2638ff57fc
parent d54932d2

system/gd/hci/le_address_rotator.cc

+2 −1
Original line number Diff line number Diff line
@@ -59,8 +59,9 @@ void LeAddressRotator::SetPrivacyPolicyForInitiatorAddress(AddressPolicy address 
  }

}



void LeAddressRotator::Register(LeAddressRotatorCallback* callback) {

LeAddressRotator::AddressPolicy LeAddressRotator::Register(LeAddressRotatorCallback* callback) {

  handler_->Post(common::BindOnce(&LeAddressRotator::register_client, common::Unretained(this), callback));

  return address_policy_;

}



void LeAddressRotator::register_client(LeAddressRotatorCallback* callback) {

system/gd/hci/le_address_rotator.h

+1 −1
Original line number Diff line number Diff line
@@ -54,7 +54,7 @@ class LeAddressRotator { 
                                           std::chrono::milliseconds maximum_rotation_time);

  void AckPause(LeAddressRotatorCallback* callback);

  void AckResume(LeAddressRotatorCallback* callback);

  virtual void Register(LeAddressRotatorCallback* callback);

  virtual AddressPolicy Register(LeAddressRotatorCallback* callback);

  virtual void Unregister(LeAddressRotatorCallback* callback);

  void OnLeSetRandomAddressComplete(bool success);

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

system/gd/hci/le_advertising_manager.cc

+120 −29
Original line number Diff line number Diff line
@@ -161,6 +161,11 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 
      return;

    }

    advertising_sets_.erase(id);

    if (advertising_sets_.empty() && address_rotator_registered) {

      le_address_rotator_->Unregister(this);

      address_rotator_registered = false;

      paused = false;

    }

  }



  void create_advertiser(AdvertiserId id, const AdvertisingConfig& config,
@@ -173,14 +178,21 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 


    if (!address_rotator_registered) {

      le_address_rotator_->Register(this);

      address_rotator_registered = true;

    }



    switch (advertising_api_type_) {

      case (AdvertisingApiType::LE_4_0):

      case (AdvertisingApiType::LE_4_0): {

        le_advertising_interface_->EnqueueCommand(

            hci::LeSetAdvertisingParametersBuilder::Create(

                config.interval_min, config.interval_max, config.event_type, config.address_type,

                config.peer_address_type, config.peer_address, config.channel_map, config.filter_policy),

                config.interval_min,

                config.interval_max,

                config.event_type,

                config.address_type,

                config.peer_address_type,

                config.peer_address,

                config.channel_map,

                config.filter_policy),

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

        if (!config.scan_response.empty()) {

          le_advertising_interface_->EnqueueCommand(
@@ -190,15 +202,28 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 
        le_advertising_interface_->EnqueueCommand(

            hci::LeSetAdvertisingDataBuilder::Create(config.advertisement),

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

        if (!paused) {

          le_advertising_interface_->EnqueueCommand(

              hci::LeSetAdvertisingEnableBuilder::Create(Enable::ENABLED),

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

        break;

      case (AdvertisingApiType::ANDROID_HCI):

        }

        EnabledSet curr_set;

        curr_set.advertising_handle_ = id;

        enabled_sets_[id] = curr_set;

      } break;

      case (AdvertisingApiType::ANDROID_HCI): {

        le_advertising_interface_->EnqueueCommand(

            hci::LeMultiAdvtParamBuilder::Create(config.interval_min, config.interval_max, config.event_type,

                                                 config.address_type, config.peer_address_type, config.peer_address,

                                                 config.channel_map, config.filter_policy, id, config.tx_power),

            hci::LeMultiAdvtParamBuilder::Create(

                config.interval_min,

                config.interval_max,

                config.event_type,

                config.address_type,

                config.peer_address_type,

                config.peer_address,

                config.channel_map,

                config.filter_policy,

                id,

                config.tx_power),

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

        le_advertising_interface_->EnqueueCommand(

            hci::LeMultiAdvtSetDataBuilder::Create(config.advertisement, id),
@@ -211,10 +236,15 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 
        le_advertising_interface_->EnqueueCommand(

            hci::LeMultiAdvtSetRandomAddrBuilder::Create(le_address_rotator_->GetAnotherAddress().GetAddress(), id),

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

        if (!paused) {

          le_advertising_interface_->EnqueueCommand(

              hci::LeMultiAdvtSetEnableBuilder::Create(Enable::ENABLED, id),

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

        break;

        }

        EnabledSet curr_set;

        curr_set.advertising_handle_ = id;

        enabled_sets_[id] = curr_set;

      } break;

      case (AdvertisingApiType::LE_5_0): {

        ExtendedAdvertisingConfig new_config = config;

        new_config.legacy_pdus = true;
@@ -232,8 +262,13 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 
      return;

    }



    advertising_sets_[id].scan_callback = scan_callback;

    advertising_sets_[id].set_terminated_callback = set_terminated_callback;

    advertising_sets_[id].handler = handler;



    if (!address_rotator_registered) {

      le_address_rotator_->Register(this);

      address_rotator_registered = true;

    }



    if (config.legacy_pdus) {
@@ -295,13 +330,11 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 
    std::vector<EnabledSet> enabled_sets = {curr_set};



    enabled_sets_[id] = curr_set;

    if (!paused) {

      le_advertising_interface_->EnqueueCommand(

          hci::LeSetExtendedAdvertisingEnableBuilder::Create(Enable::ENABLED, enabled_sets),

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



    advertising_sets_[id].scan_callback = scan_callback;

    advertising_sets_[id].set_terminated_callback = set_terminated_callback;

    advertising_sets_[id].handler = handler;

    }

  }



  void stop_advertising(AdvertiserId advertising_set) {
@@ -332,23 +365,80 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 


    std::unique_lock lock(id_mutex_);

    enabled_sets_[advertising_set].advertising_handle_ = -1;

    advertising_sets_.erase(advertising_set);

  }



  void OnPause() override {

    paused = true;

    if (!advertising_sets_.empty()) {

      switch (advertising_api_type_) {

        case (AdvertisingApiType::LE_4_0): {

          le_advertising_interface_->EnqueueCommand(

              hci::LeSetAdvertisingEnableBuilder::Create(Enable::DISABLED),

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

        } break;

        case (AdvertisingApiType::ANDROID_HCI): {

          for (size_t i = 0; i < enabled_sets_.size(); i++) {

            uint8_t id = enabled_sets_[i].advertising_handle_;

            if (id != -1) {

              le_advertising_interface_->EnqueueCommand(

                  hci::LeMultiAdvtSetEnableBuilder::Create(Enable::DISABLED, id),

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

            }

          }

        } break;

        case (AdvertisingApiType::LE_5_0): {

          std::vector<EnabledSet> enabled_sets = {};

          for (size_t i = 0; i < enabled_sets_.size(); i++) {

            EnabledSet curr_set = enabled_sets_[i];

            if (enabled_sets_[i].advertising_handle_ != -1) {

              enabled_sets.push_back(enabled_sets_[i]);

            }

          }

          if (enabled_sets.size() != 0) {

            le_advertising_interface_->EnqueueCommand(

                hci::LeSetExtendedAdvertisingEnableBuilder::Create(Enable::DISABLED, enabled_sets),

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

          }

        } break;

      }

    }

    le_address_rotator_->AckPause(this);

  }



  void OnResume() override {

    paused = false;

    if (!advertising_sets_.empty()) {

      switch (advertising_api_type_) {

        case (AdvertisingApiType::LE_4_0): {

          le_advertising_interface_->EnqueueCommand(

              hci::LeSetAdvertisingEnableBuilder::Create(Enable::ENABLED),

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

        } break;

        case (AdvertisingApiType::ANDROID_HCI): {

          for (size_t i = 0; i < enabled_sets_.size(); i++) {

            uint8_t id = enabled_sets_[i].advertising_handle_;

            if (id != -1) {

              le_advertising_interface_->EnqueueCommand(

                  hci::LeMultiAdvtSetEnableBuilder::Create(Enable::ENABLED, id),

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

            }

          }

        } break;

        case (AdvertisingApiType::LE_5_0): {

          std::vector<EnabledSet> enabled_sets = {};

          for (size_t i = 0; i < enabled_sets_.size(); i++) {

            EnabledSet curr_set = enabled_sets_[i];

            if (enabled_sets_[i].advertising_handle_ != -1) {

              enabled_sets.push_back(enabled_sets_[i]);

            }

          }

          if (enabled_sets.size() != 0) {

            le_advertising_interface_->EnqueueCommand(

                hci::LeSetExtendedAdvertisingEnableBuilder::Create(Enable::ENABLED, enabled_sets),

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

          }

        } break;

      }

    }

    le_address_rotator_->AckResume(this);

  }
@@ -364,6 +454,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressRotatorCallb 
  std::map<AdvertiserId, Advertiser> advertising_sets_;

  hci::LeAddressRotator* le_address_rotator_;

  bool address_rotator_registered = false;

  bool paused = false;



  std::mutex id_mutex_;

  size_t num_instances_;

system/gd/hci/le_advertising_manager_test.cc

+3 −1
Original line number Diff line number Diff line
@@ -208,7 +208,9 @@ class TestLeAddressRotator : public LeAddressRotator { 
                       Address public_address)

      : LeAddressRotator(set_random_address, handler, public_address) {}



  void Register(LeAddressRotatorCallback* callback) override {}

  AddressPolicy Register(LeAddressRotatorCallback* callback) override {

    return AddressPolicy::USE_STATIC_ADDRESS;

  }



  void Unregister(LeAddressRotatorCallback* callback) override {}

system/gd/hci/le_scanning_manager.cc

+22 −10
Original line number Diff line number Diff line
@@ -150,11 +150,19 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressRotatorCallback 
  }



  void start_scan(LeScanningManagerCallbacks* le_scanning_manager_callbacks) {

    registered_callback_ = le_scanning_manager_callbacks;



    if (!address_rotator_registered) {

      le_address_rotator_->Register(this);

      address_rotator_registered = true;

    }



    // If we receive start_scan during paused, replace the cached_registered_callback_ for OnResume

    if (cached_registered_callback_ != nullptr) {

      cached_registered_callback_ = registered_callback_;

      return;

    }



    registered_callback_ = le_scanning_manager_callbacks;

    switch (api_type_) {

      case ScanApiType::LE_5_0:

        le_scanning_interface_->EnqueueCommand(
@@ -171,7 +179,12 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressRotatorCallback 
    }

  }



  void stop_scan(common::Callback<void()> on_stopped) {

  void stop_scan(common::Callback<void()> on_stopped, bool from_on_pause) {

    if (address_rotator_registered && !from_on_pause) {

      cached_registered_callback_ = nullptr;

      le_address_rotator_->Unregister(this);

      address_rotator_registered = false;

    }

    if (registered_callback_ == nullptr) {

      return;

    }
@@ -195,11 +208,8 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressRotatorCallback 
  }



  void OnPause() override {

    if (registered_callback_ == nullptr) {

      le_address_rotator_->AckPause(this);

    } else {

      stop_scan(common::Bind(&impl::ack_pause, common::Unretained(this)));

    }

    cached_registered_callback_ = registered_callback_;

    stop_scan(common::Bind(&impl::ack_pause, common::Unretained(this)), true);

  }



  void ack_pause() {
@@ -207,8 +217,9 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressRotatorCallback 
  }



  void OnResume() override {

    if (registered_callback_ != nullptr) {

      start_scan(registered_callback_);

    if (cached_registered_callback_ != nullptr) {

      start_scan(cached_registered_callback_);

      cached_registered_callback_ = nullptr;

    }

    le_address_rotator_->AckResume(this);

  }
@@ -216,6 +227,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressRotatorCallback 
  ScanApiType api_type_;



  LeScanningManagerCallbacks* registered_callback_ = nullptr;

  LeScanningManagerCallbacks* cached_registered_callback_ = nullptr;

  Module* module_;

  os::Handler* module_handler_;

  hci::HciLayer* hci_layer_;
@@ -290,7 +302,7 @@ void LeScanningManager::StartScan(LeScanningManagerCallbacks* callbacks) { 
}



void LeScanningManager::StopScan(common::Callback<void()> on_stopped) {

  GetHandler()->Post(common::Bind(&impl::stop_scan, common::Unretained(pimpl_.get()), on_stopped));

  GetHandler()->Post(common::Bind(&impl::stop_scan, common::Unretained(pimpl_.get()), on_stopped, false));

}



}  // namespace hci