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

Commit 92521df2 authored by Rongxuan Liu's avatar Rongxuan Liu
Browse files

[le audio] Use gd advertiser for broadcast advertising 

Currently broadcast is using the deprecated multi_adv for advertising and this caused conflicts with gd advertiser.
This change updated LEA broadcast to use gd advertiser and change unit tests interface accordingly.

Bug: 268305859
Tag: #refactor
Test: atest bluetooth_test_broadcaster bluetooth_test_broadcaster_state_machine
Change-Id: Ibd67f876d625f23bc3bafa3b71d46c9855781380
parent bc4fa9ae

system/bta/le_audio/broadcaster/broadcaster.cc

+91 −2
Original line number Diff line number Diff line
@@ -91,7 +91,8 @@ class LeAudioBroadcasterImpl : public LeAudioBroadcaster, public BigCallbacks { 
    LOG_INFO();



    /* Register State machine callbacks */

    BroadcastStateMachine::Initialize(&state_machine_callbacks_);

    BroadcastStateMachine::Initialize(&state_machine_callbacks_,

                                      &state_machine_adv_callbacks_);



    GenerateBroadcastIds();

  }
@@ -834,6 +835,93 @@ class LeAudioBroadcasterImpl : public LeAudioBroadcaster, public BigCallbacks { 
    }

  } state_machine_callbacks_;



  static class BroadcastAdvertisingCallbacks : public AdvertisingCallbacks {

    void OnAdvertisingSetStarted(int reg_id, uint8_t advertiser_id,

                                 int8_t tx_power, uint8_t status) {

      if (!instance) return;



      if (reg_id == BroadcastStateMachine::kLeAudioBroadcastRegId &&

          !instance->pending_broadcasts_.empty()) {

        instance->pending_broadcasts_.back()->OnCreateAnnouncement(

            advertiser_id, tx_power, status);

      } else {

        LOG_WARN(

            "Ignored OnAdvertisingSetStarted callback reg_id:%d "

            "advertiser_id:%d",

            reg_id, advertiser_id);

      }

    }



    void OnAdvertisingEnabled(uint8_t advertiser_id, bool enable,

                              uint8_t status) {

      if (!instance) return;



      auto const& iter = std::find_if(

          instance->broadcasts_.cbegin(), instance->broadcasts_.cend(),

          [advertiser_id](auto const& sm) {

            return sm.second->GetAdvertisingSid() == advertiser_id;

          });

      if (iter != instance->broadcasts_.cend()) {

        iter->second->OnEnableAnnouncement(enable, status);

      } else {

        LOG_WARN("Ignored OnAdvertisingEnabled callback advertiser_id:%d",

                 advertiser_id);

      }

    }



    void OnAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) {

      LOG_WARN(

          "Not being used, ignored OnAdvertisingDataSet callback "

          "advertiser_id:%d",

          advertiser_id);

    }



    void OnScanResponseDataSet(uint8_t advertiser_id, uint8_t status) {

      LOG_WARN(

          "Not being used, ignored OnScanResponseDataSet callback "

          "advertiser_id:%d",

          advertiser_id);

    }



    void OnAdvertisingParametersUpdated(uint8_t advertiser_id, int8_t tx_power,

                                        uint8_t status) {

      LOG_WARN(

          "Not being used, ignored OnAdvertisingParametersUpdated callback "

          "advertiser_id:%d",

          advertiser_id);

    }



    void OnPeriodicAdvertisingParametersUpdated(uint8_t advertiser_id,

                                                uint8_t status) {

      LOG_WARN(

          "Not being used, ignored OnPeriodicAdvertisingParametersUpdated "

          "callback advertiser_id:%d",

          advertiser_id);

    }



    void OnPeriodicAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) {

      LOG_WARN(

          "Not being used, ignored OnPeriodicAdvertisingDataSet callback "

          "advertiser_id:%d",

          advertiser_id);

    }



    void OnPeriodicAdvertisingEnabled(uint8_t advertiser_id, bool enable,

                                      uint8_t status) {

      LOG_WARN(

          "Not being used, ignored OnPeriodicAdvertisingEnabled callback "

          "advertiser_id:%d",

          advertiser_id);

    }



    void OnOwnAddressRead(uint8_t advertiser_id, uint8_t address_type,

                          RawAddress address) {

      LOG_WARN(

          "Not being used, ignored OnOwnAddressRead callback advertiser_id:%d",

          advertiser_id);

    }

  } state_machine_adv_callbacks_;



  static class LeAudioSourceCallbacksImpl

      : public LeAudioSourceAudioHalClient::Callbacks {

   public:
@@ -1016,7 +1104,8 @@ LeAudioBroadcasterImpl::BroadcastStateMachineCallbacks 
    LeAudioBroadcasterImpl::state_machine_callbacks_;

LeAudioBroadcasterImpl::LeAudioSourceCallbacksImpl

    LeAudioBroadcasterImpl::audio_receiver_;



LeAudioBroadcasterImpl::BroadcastAdvertisingCallbacks

    LeAudioBroadcasterImpl::state_machine_adv_callbacks_;

} /* namespace */



void LeAudioBroadcaster::Initialize(

system/bta/le_audio/broadcaster/mock_ble_advertising_manager.cc

+14 −14
Original line number Diff line number Diff line
@@ -20,27 +20,27 @@ 
#include <base/memory/weak_ptr.h>



#include "ble_advertiser_hci_interface.h"

#include "main/shim/le_advertising_manager.h"



namespace {

BleAdvertisingManager* instance;

base::WeakPtr<MockBleAdvertisingManager> instance_weakptr;

MockBleAdvertisingManager* bt_le_advertiser_instance;

}  // namespace



void BleAdvertisingManager::Initialize(BleAdvertiserHciInterface* interface) {

  MockBleAdvertisingManager* manager = new MockBleAdvertisingManager();

  manager->SetBleAdvertiserHciInterfaceForTesting(interface);



  instance = manager;

  instance_weakptr = ((MockBleAdvertisingManager*)instance)->GetWeakPtr();

void MockBleAdvertisingManager::Initialize() {

  if (bt_le_advertiser_instance == nullptr) {

    bt_le_advertiser_instance = new MockBleAdvertisingManager();

  }

}



void BleAdvertisingManager::CleanUp() {

  delete instance;

  instance = nullptr;

void MockBleAdvertisingManager::CleanUp() {

  delete bt_le_advertiser_instance;

  bt_le_advertiser_instance = nullptr;

}



bool BleAdvertisingManager::IsInitialized() { return instance; }

MockBleAdvertisingManager* MockBleAdvertisingManager::Get() {

  return bt_le_advertiser_instance;

}



base::WeakPtr<BleAdvertisingManager> BleAdvertisingManager::Get() {

  return instance_weakptr;

BleAdvertiserInterface* bluetooth::shim::get_ble_advertiser_instance() {

  return static_cast<BleAdvertiserInterface*>(bt_le_advertiser_instance);

}

system/bta/le_audio/broadcaster/mock_ble_advertising_manager.h

+33 −53
Original line number Diff line number Diff line
@@ -23,8 +23,9 @@ 
#include <gmock/gmock.h>



#include "ble_advertiser.h"

#include "include/hardware/ble_advertiser.h"



class MockBleAdvertisingManager : public BleAdvertisingManager {

class MockBleAdvertisingManager : public BleAdvertiserInterface {

 public:

  MockBleAdvertisingManager() = default;

  MockBleAdvertisingManager(const MockBleAdvertisingManager&) = delete;
@@ -33,77 +34,56 @@ class MockBleAdvertisingManager : public BleAdvertisingManager { 


  ~MockBleAdvertisingManager() override = default;



  /* Allows getting and setting BleAdvertiserHciInterface dependency */

  BleAdvertiserHciInterface* GetBleAdvertiserHciInterface() {

    return ble_adv_hci_interface_;

  }

  void SetBleAdvertiserHciInterfaceForTesting(

      BleAdvertiserHciInterface* interface) {

    ble_adv_hci_interface_ = interface;

  }



  base::WeakPtr<MockBleAdvertisingManager> GetWeakPtr() {

    return weak_factory_.GetWeakPtr();

  }

  static void Initialize();

  static void CleanUp();

  static MockBleAdvertisingManager* Get();



  MOCK_METHOD((void), StartAdvertising,

              (uint8_t advertiser_id, MultiAdvCb cb,

               tBTM_BLE_ADV_PARAMS* params, std::vector<uint8_t> advertise_data,

               std::vector<uint8_t> scan_response_data, int duration,

              (uint8_t advertiser_id, StatusCallback cb,

               AdvertiseParameters params, std::vector<uint8_t> advertise_data,

               std::vector<uint8_t> scan_response_data, int timeout_s,

               MultiAdvCb timeout_cb),

              (override));

  MOCK_METHOD((void), StartAdvertisingSet,

              (base::Callback<void(uint8_t /* inst_id */, int8_t /* tx_power */,

                                   uint8_t /* status */)>

                   cb,

               tBTM_BLE_ADV_PARAMS* params, std::vector<uint8_t> advertise_data,

              (uint8_t client_id, int reg_id,

               IdTxPowerStatusCallback register_cb, AdvertiseParameters params,

               std::vector<uint8_t> advertise_data,

               std::vector<uint8_t> scan_response_data,

               tBLE_PERIODIC_ADV_PARAMS* periodic_params,

               PeriodicAdvertisingParameters periodic_params,

               std::vector<uint8_t> periodic_data, uint16_t duration,

               uint8_t maxExtAdvEvents,

               base::Callback<void(uint8_t /* inst_id */, uint8_t /* status */)>

                   timeout_cb),

              (override));

  MOCK_METHOD((void), RegisterAdvertiser,

              (base::Callback<void(uint8_t inst_id, uint8_t status)>),

               uint8_t maxExtAdvEvents, IdStatusCallback timeout_cb),

              (override));

  MOCK_METHOD((void), RegisterAdvertiser, (IdStatusCallback cb), (override));

  MOCK_METHOD((void), Enable,

              (uint8_t inst_id, bool enable, MultiAdvCb cb, uint16_t duration,

               uint8_t maxExtAdvEvents, MultiAdvCb timeout_cb),

              (uint8_t advertiser_id, bool enable, StatusCallback cb,

               uint16_t duration, uint8_t maxExtAdvEvents,

               StatusCallback timeout_cb),

              (override));

  MOCK_METHOD((void), SetParameters,

              (uint8_t inst_id, tBTM_BLE_ADV_PARAMS* p_params, ParametersCb cb),

              (uint8_t advertiser_id, AdvertiseParameters params,

               ParametersCallback cb),

              (override));

  MOCK_METHOD((void), SetData,

              (uint8_t inst_id, bool is_scan_rsp, std::vector<uint8_t> data,

               MultiAdvCb cb),

              (int advertiser_id, bool set_scan_rsp, std::vector<uint8_t> data,

               StatusCallback cb),

              (override));

  MOCK_METHOD((void), SetPeriodicAdvertisingParameters,

              (uint8_t inst_id, tBLE_PERIODIC_ADV_PARAMS* params,

               MultiAdvCb cb),

              (int advertiser_id, PeriodicAdvertisingParameters periodic_params,

               StatusCallback cb),

              (override));

  MOCK_METHOD((void), SetPeriodicAdvertisingData,

              (uint8_t inst_id, std::vector<uint8_t> data, MultiAdvCb cb),

              (int advertiser_id, std::vector<uint8_t> data, StatusCallback cb),

              (override));

  MOCK_METHOD((void), SetPeriodicAdvertisingEnable,

              (uint8_t inst_id, bool enable, bool include_adi, MultiAdvCb cb),

              (int advertiser_id, bool enable, bool include_adi,

               StatusCallback cb),

              (override));

  MOCK_METHOD((void), Unregister, (uint8_t inst_id), (override));

  MOCK_METHOD((void), Suspend, (), (override));

  MOCK_METHOD((void), Resume, (), (override));

  MOCK_METHOD((void), OnAdvertisingSetTerminated,

              (uint8_t status, uint8_t advertising_handle,

               uint16_t connection_handle,

               uint8_t num_completed_extended_adv_events),

  MOCK_METHOD((void), Unregister, (uint8_t advertiser_id), (override));

  MOCK_METHOD((void), GetOwnAddress,

              (uint8_t advertiser_id, GetAddressCallback cb), (override));

  MOCK_METHOD((void), RegisterCallbacks, (AdvertisingCallbacks * callbacks),

              (override));

  MOCK_METHOD(

      (void), GetOwnAddress,

      (uint8_t inst_id,

       base::Callback<void(uint8_t /* address_type*/, RawAddress /*address*/)>

           cb),

  MOCK_METHOD((void), RegisterCallbacksNative,

              (AdvertisingCallbacks * callbacks, uint8_t client_id),

              (override));



 private:

  base::WeakPtrFactory<MockBleAdvertisingManager> weak_factory_{this};

  BleAdvertiserHciInterface* ble_adv_hci_interface_;

};

system/bta/le_audio/broadcaster/mock_state_machine.cc

+6 −3
Original line number Diff line number Diff line
@@ -20,14 +20,17 @@ 
using namespace le_audio::broadcaster;



IBroadcastStateMachineCallbacks* callbacks;

void BroadcastStateMachine::Initialize(IBroadcastStateMachineCallbacks* cb) {

AdvertisingCallbacks* adv_callbacks;

void BroadcastStateMachine::Initialize(IBroadcastStateMachineCallbacks* cb,

                                       AdvertisingCallbacks* adv_cb) {

  callbacks = cb;

  adv_callbacks = adv_cb;

}



std::unique_ptr<BroadcastStateMachine> BroadcastStateMachine::CreateInstance(

    BroadcastStateMachineConfig msg) {

  auto instance =

      std::make_unique<MockBroadcastStateMachine>(std::move(msg), callbacks);

  auto instance = std::make_unique<MockBroadcastStateMachine>(

      std::move(msg), callbacks, adv_callbacks);

  MockBroadcastStateMachine::last_instance_ = instance.get();

  return std::move(instance);

}

system/bta/le_audio/broadcaster/mock_state_machine.h

+9 −2
Original line number Diff line number Diff line
@@ -26,8 +26,9 @@ class MockBroadcastStateMachine 
 public:

  MockBroadcastStateMachine(

      le_audio::broadcaster::BroadcastStateMachineConfig cfg,

      le_audio::broadcaster::IBroadcastStateMachineCallbacks* cb)

      : cfg(cfg), cb(cb) {

      le_audio::broadcaster::IBroadcastStateMachineCallbacks* cb,

      AdvertisingCallbacks* adv_cb)

      : cfg(cfg), cb(cb), adv_cb(adv_cb) {

    advertising_sid_ = ++instance_counter_;



    ON_CALL(*this, Initialize).WillByDefault([this]() {
@@ -149,11 +150,17 @@ class MockBroadcastStateMachine 
               const void* data),

              (override));

  MOCK_METHOD((uint8_t), GetAdvertisingSid, (), (const override));

  MOCK_METHOD((void), OnCreateAnnouncement,

              (uint8_t advertising_sid, int8_t tx_power, uint8_t status),

              (override));

  MOCK_METHOD((void), OnEnableAnnouncement, (bool enable, uint8_t status),

              (override));



  bool result_ = true;

  std::optional<le_audio::broadcaster::BigConfig> big_config_ = std::nullopt;

  le_audio::broadcaster::BroadcastStateMachineConfig cfg;

  le_audio::broadcaster::IBroadcastStateMachineCallbacks* cb;

  AdvertisingCallbacks* adv_cb;

  void SetExpectedState(BroadcastStateMachine::State state) { SetState(state); }

  void SetExpectedResult(bool result) { result_ = result; }

  void SetExpectedBigConfig(