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

Commit 77fe1ca3 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Refactor advertising callback mechanism for GD"

parents 8eb2d0c0 2d582341

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

}