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

Commit 2d582341 authored by Chienyuan's avatar Chienyuan Committed by Chienyuan Huang
Browse files

Refactor advertising callback mechanism for GD 

Tag: #refactor
Bug: 169390539
Test: all sl4a tests for BLE advertising
Change-Id: If16058fa2ca07d27bf3a340b0aaff51e0f7ec232
parent affdbada

system/btif/src/btif_ble_advertiser.cc

+5 −1
Original line number Diff line number Diff line
@@ -182,7 +182,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface { 
             timeout_s * 100, jni_thread_wrapper(FROM_HERE, timeout_cb)));

  }



  void StartAdvertisingSet(IdTxPowerStatusCallback cb,

  void StartAdvertisingSet(int reg_id, IdTxPowerStatusCallback cb,

                           AdvertiseParameters params,

                           std::vector<uint8_t> advertise_data,

                           std::vector<uint8_t> scan_response_data,
@@ -248,6 +248,10 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface { 
                           BleAdvertisingManager::Get(), advertiser_id, enable,

                           jni_thread_wrapper(FROM_HERE, cb)));

  }



  void RegisterCallbacks(AdvertisingCallbacks* callbacks) {

    // For GD only

  }

};



BleAdvertiserInterface* btLeAdvertiserInstance = nullptr;

system/gd/hci/le_advertising_manager.cc

+75 −15
Original line number Diff line number Diff line
@@ -282,16 +282,21 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
        // sid must be in range 0x00 to 0x0F. Since no controller supports more than

        // 16 advertisers, it's safe to make sid equal to id.

        new_config.sid = id % 0x0F;



        create_extended_advertiser(id, new_config, scan_callback, set_terminated_callback, handler);

        // TODO remove, always call create_advertiser via create_extended_advertiser

        create_extended_advertiser(0x00, id, new_config, scan_callback, set_terminated_callback, handler);

      } break;

    }

  }



  void create_extended_advertiser(AdvertiserId id, const ExtendedAdvertisingConfig& config,

  void create_extended_advertiser(

      int reg_id,

      AdvertiserId id,

      const ExtendedAdvertisingConfig& config,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      os::Handler* handler) {

    id_map_[id] = reg_id;



    if (advertising_api_type_ != AdvertisingApiType::LE_5_0) {

      create_advertiser(id, config, scan_callback, set_terminated_callback, handler);

      return;
@@ -559,6 +564,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
  std::mutex id_mutex_;

  size_t num_instances_;

  std::vector<hci::EnabledSet> enabled_sets_;

  std::map<uint8_t, int> id_map_;



  AdvertisingApiType advertising_api_type_{0};
@@ -566,7 +572,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
  void on_set_advertising_enable_complete(

      Enable enable, std::vector<EnabledSet> enabled_sets, CommandCompleteView view) {

    ASSERT(view.IsValid());

    auto complete_view = LeSetAdvertisingEnableCompleteView::Create(view);

    auto complete_view = View::Create(view);

    ASSERT(complete_view.IsValid());

    AdvertisingCallback::AdvertisingStatus advertising_status = AdvertisingCallback::AdvertisingStatus::SUCCESS;

    if (complete_view.GetStatus() != ErrorCode::SUCCESS) {
@@ -582,9 +588,9 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
        continue;

      }

      if (enable == Enable::ENABLED) {

        advertising_callbacks_->onAdvertisingEnabled(id, true, advertising_status);

        advertising_callbacks_->OnAdvertisingEnabled(id, true, advertising_status);

      } else {

        advertising_callbacks_->onAdvertisingEnabled(id, false, advertising_status);

        advertising_callbacks_->OnAdvertisingEnabled(id, false, advertising_status);

      }

    }

  }
@@ -612,9 +618,10 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
        continue;

      }

      if (enable == Enable::ENABLED) {

        advertising_callbacks_->OnAdvertisingSetStarted(id, tx_power, advertising_status);

        int reg_id = id_map_[id];

        advertising_callbacks_->OnAdvertisingSetStarted(reg_id, id, tx_power, advertising_status);

      } else {

        advertising_callbacks_->onAdvertisingEnabled(id, false, advertising_status);

        advertising_callbacks_->OnAdvertisingEnabled(id, false, advertising_status);

      }

    }

  }
@@ -631,6 +638,49 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
    advertising_sets_[id].tx_power = complete_view.GetSelectedTxPower();

  }



  template <class View>

  void check_status_with_id(AdvertiserId id, CommandCompleteView view) {

    ASSERT(view.IsValid());

    auto status_view = View::Create(view);

    ASSERT(status_view.IsValid());

    if (status_view.GetStatus() != ErrorCode::SUCCESS) {

      LOG_INFO(

          "Got a Command complete %s, status %s",

          OpCodeText(view.GetCommandOpCode()).c_str(),

          ErrorCodeText(status_view.GetStatus()).c_str());

    }

    AdvertisingCallback::AdvertisingStatus advertising_status = AdvertisingCallback::AdvertisingStatus::SUCCESS;

    if (status_view.GetStatus() != ErrorCode::SUCCESS) {

      LOG_INFO("Got a command complete with status %s", ErrorCodeText(status_view.GetStatus()).c_str());

      advertising_status = AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR;

    }



    if (advertising_callbacks_ == nullptr) {

      return;

    }



    OpCode opcode = view.GetCommandOpCode();



    switch (opcode) {

      case OpCode::LE_SET_ADVERTISING_DATA:

      case OpCode::LE_SET_EXTENDED_ADVERTISING_DATA:

        advertising_callbacks_->OnAdvertisingDataSet(id, advertising_status);

        break;

      case OpCode::LE_SET_SCAN_RESPONSE_DATA:

      case OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE:

        advertising_callbacks_->OnScanResponseDataSet(id, advertising_status);

        break;

      case OpCode::LE_SET_PERIODIC_ADVERTISING_PARAM:

        advertising_callbacks_->OnPeriodicAdvertisingParametersUpdated(id, advertising_status);

        break;

      case OpCode::LE_SET_PERIODIC_ADVERTISING_DATA:

        advertising_callbacks_->OnPeriodicAdvertisingDataSet(id, advertising_status);

        break;

      default:

        LOG_WARN("Unexpected event type %s", OpCodeText(view.GetCommandOpCode()).c_str());

    }

  }



  template <class View>

  static void check_status(CommandCompleteView view) {

    ASSERT(view.IsValid());
@@ -697,8 +747,11 @@ AdvertiserId LeAdvertisingManager::CreateAdvertiser( 
}



AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser(

    const ExtendedAdvertisingConfig& config, const common::Callback<void(Address, AddressType)>& scan_callback,

    const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback, os::Handler* handler) {

    int reg_id,

    const ExtendedAdvertisingConfig& config,

    const common::Callback<void(Address, AddressType)>& scan_callback,

    const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

    os::Handler* handler) {

  if (config.directed) {

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

      LOG_INFO("Peer address can not be empty for directed advertising");
@@ -727,8 +780,15 @@ AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser( 
  if (id == kInvalidId) {

    return id;

  }

  GetHandler()->Post(common::BindOnce(&impl::create_extended_advertiser, common::Unretained(pimpl_.get()), id, config,

                                      scan_callback, set_terminated_callback, handler));

  CallOn(

      pimpl_.get(),

      &impl::create_extended_advertiser,

      reg_id,

      id,

      config,

      scan_callback,

      set_terminated_callback,

      handler);

  return id;

}

system/gd/hci/le_advertising_manager.h

+14 −4
Original line number Diff line number Diff line
@@ -74,8 +74,15 @@ class AdvertisingCallback { 
  };



  virtual ~AdvertisingCallback() = default;

  virtual void OnAdvertisingSetStarted(uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status) = 0;

  virtual void onAdvertisingEnabled(uint8_t advertiser_id, bool enable, uint8_t status) = 0;

  virtual void OnAdvertisingSetStarted(

      int reg_id, uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status) = 0;

  virtual void OnAdvertisingEnabled(uint8_t advertiser_id, bool enable, uint8_t status) = 0;

  virtual void OnAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) = 0;

  virtual void OnScanResponseDataSet(uint8_t advertiser_id, uint8_t status) = 0;

  virtual void OnAdvertisingParametersUpdated(uint8_t advertiser_id, int8_t tx_power, uint8_t status) = 0;

  virtual void OnPeriodicAdvertisingParametersUpdated(uint8_t advertiser_id, uint8_t status) = 0;

  virtual void OnPeriodicAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) = 0;

  virtual void OnPeriodicAdvertisingEnabled(uint8_t advertiser_id, bool enable, uint8_t status) = 0;

};



class LeAdvertisingManager : public bluetooth::Module {
@@ -92,8 +99,11 @@ class LeAdvertisingManager : public bluetooth::Module { 
                                const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

                                os::Handler* handler);

  AdvertiserId ExtendedCreateAdvertiser(

      const ExtendedAdvertisingConfig& config, const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback, os::Handler* handler);

      int reg_id,

      const ExtendedAdvertisingConfig& config,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      os::Handler* handler);



  void RemoveAdvertiser(AdvertiserId id);

system/gd/hci/le_advertising_manager_mock.h

+2 −1
Original line number Diff line number Diff line
@@ -43,7 +43,8 @@ class MockLeAdvertisingManager : public LeAdvertisingManager { 
  MOCK_METHOD(

      AdvertiserId,

      ExtendedCreateAdvertiser,

      (const ExtendedAdvertisingConfig&,

      (int regId,

       const ExtendedAdvertisingConfig&,

       const common::Callback<void(Address, AddressType)>&,

       const common::Callback<void(ErrorCode, uint8_t, uint8_t)>&,

       os::Handler*));

system/gd/hci/le_advertising_manager_test.cc

+16 −8
Original line number Diff line number Diff line
@@ -338,8 +338,15 @@ class LeAdvertisingManagerTest : public ::testing::Test { 


  class MockAdvertisingCallback : public AdvertisingCallback {

   public:

    MOCK_METHOD3(OnAdvertisingSetStarted, void(uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status));

    MOCK_METHOD3(onAdvertisingEnabled, void(uint8_t advertiser_id, bool enable, uint8_t status));

    MOCK_METHOD4(

        OnAdvertisingSetStarted, void(int reg_id, uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status));

    MOCK_METHOD3(OnAdvertisingEnabled, void(uint8_t advertiser_id, bool enable, uint8_t status));

    MOCK_METHOD2(OnAdvertisingDataSet, void(uint8_t advertiser_id, uint8_t status));

    MOCK_METHOD2(OnScanResponseDataSet, void(uint8_t advertiser_id, uint8_t status));

    MOCK_METHOD3(OnAdvertisingParametersUpdated, void(uint8_t advertiser_id, int8_t tx_power, uint8_t status));

    MOCK_METHOD2(OnPeriodicAdvertisingParametersUpdated, void(uint8_t advertiser_id, uint8_t status));

    MOCK_METHOD2(OnPeriodicAdvertisingDataSet, void(uint8_t advertiser_id, uint8_t status));

    MOCK_METHOD3(OnPeriodicAdvertisingEnabled, void(uint8_t advertiser_id, bool enable, uint8_t status));

  } mock_advertising_callback_;

};
@@ -393,7 +400,7 @@ TEST_F(LeAdvertisingManagerTest, create_advertiser_test) { 
      OpCode::LE_SET_ADVERTISING_ENABLE,

  };

  EXPECT_CALL(

      mock_advertising_callback_, onAdvertisingEnabled(id, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));

      mock_advertising_callback_, OnAdvertisingEnabled(id, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));



  std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};

  auto result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
@@ -411,7 +418,7 @@ TEST_F(LeAdvertisingManagerTest, create_advertiser_test) { 
  result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));

  ASSERT_EQ(std::future_status::ready, result);

  EXPECT_CALL(

      mock_advertising_callback_, onAdvertisingEnabled(id, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));

      mock_advertising_callback_, OnAdvertisingEnabled(id, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));

  test_hci_layer_->IncomingEvent(LeSetAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));

  sync_client_handler();

}
@@ -475,11 +482,12 @@ TEST_F(LeExtendedAdvertisingManagerTest, create_advertiser_test) { 
  advertising_config.sid = 0x01;



  auto last_command_future = test_hci_layer_->GetCommandFuture(OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE);

  auto id = le_advertising_manager_->ExtendedCreateAdvertiser(advertising_config, scan_callback,

                                                              set_terminated_callback, client_handler_);

  auto id = le_advertising_manager_->ExtendedCreateAdvertiser(

      0x00, advertising_config, scan_callback, set_terminated_callback, client_handler_);

  ASSERT_NE(LeAdvertisingManager::kInvalidId, id);

  EXPECT_CALL(

      mock_advertising_callback_, OnAdvertisingSetStarted(id, -23, AdvertisingCallback::AdvertisingStatus::SUCCESS));

      mock_advertising_callback_,

      OnAdvertisingSetStarted(0x00, id, -23, AdvertisingCallback::AdvertisingStatus::SUCCESS));

  std::vector<OpCode> adv_opcodes = {

      OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS,

      OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE,
@@ -508,7 +516,7 @@ TEST_F(LeExtendedAdvertisingManagerTest, create_advertiser_test) { 
  result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));

  ASSERT_EQ(std::future_status::ready, result);

  EXPECT_CALL(

      mock_advertising_callback_, onAdvertisingEnabled(id, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));

      mock_advertising_callback_, OnAdvertisingEnabled(id, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));

  test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));

  sync_client_handler();

}