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

Commit 0266c454 authored by Rongxuan Liu's avatar Rongxuan Liu Committed by Gerrit Code Review
Browse files

Merge changes I1b4a96cd,Ibd67f876,I86176db4 into main 

* changes:
  Remove unused multi_adv le adversiting module and its unit test
  [le audio] Use gd advertiser for broadcast advertising
  Extend le_advertising_manager for registering callback by native clients
parents 8b27b44e 72f12ba1

TEST_MAPPING

+0 −6
Original line number Diff line number Diff line
@@ -69,9 +69,6 @@ 
    {

      "name": "net_test_stack_ad_parser"

    },

    {

      "name": "net_test_stack_multi_adv"

    },

    // go/a-unit-tests tests (unit_test: true)

    // Thoses test run on the host in the CI automatically.

    // Run the one that are available on the device on the
@@ -279,9 +276,6 @@ 
    {

      "name": "net_test_stack_ad_parser"

    },

    {

      "name": "net_test_stack_multi_adv"

    },

    // go/a-unit-tests tests (unit_test: true)

    // Thoses test run on the host in the CI automatically.

    // Run the one that are available on the device on the

android/app/jni/com_android_bluetooth_gatt.cpp

+4 −3
Original line number Diff line number Diff line
@@ -2400,9 +2400,10 @@ static void startAdvertisingSetNative( 
  env->ReleaseByteArrayElements(periodic_data, periodic_data_data, JNI_ABORT);



  sGattIf->advertiser->StartAdvertisingSet(

      reg_id, base::Bind(&ble_advertising_set_started_cb, reg_id, server_if),

      params, data_vec, scan_resp_vec, periodicParams, periodic_data_vec,

      duration, maxExtAdvEvents, base::Bind(ble_advertising_set_timeout_cb));

      kAdvertiserClientIdJni, reg_id,

      base::Bind(&ble_advertising_set_started_cb, reg_id, server_if), params,

      data_vec, scan_resp_vec, periodicParams, periodic_data_vec, duration,

      maxExtAdvEvents, base::Bind(ble_advertising_set_timeout_cb));

}



static void stopAdvertisingSetNative(JNIEnv* env, jobject object,

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_;

};