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

Commit 9f55e3b8 authored by Myles Watson's avatar Myles Watson
Browse files

Reland: Add tests for BQR Events 

Test sending BQR events and make sure callbacks
are called and the evenet FIFO contains the correct
events.

Bug: 322230000
Test: atest net_test_btif_stack
Flag: EXEMPT, simple bug fix
Change-Id: Ia99e56b9e6019a1637204a7e53fce6579d1810f3
parent 00ee4d19

system/btif/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -735,6 +735,7 @@ cc_test { 
        "libbluetooth-types",

        "libbluetooth_crypto_toolbox",

        "libbluetooth_gd",

        "libbluetooth_hci_pdl",

        "libbluetooth_log",

        "libbt-audio-hal-interface",

        "libbt-btu-main-thread",
@@ -752,6 +753,7 @@ cc_test { 
        "libchrome",

        "libcom.android.sysprop.bluetooth.wrapped",

        "libevent",

        "libflatbuffers-cpp",

        "libgmock",

        "libprotobuf-cpp-lite",

        "libstatslog_bt",

system/btif/include/btif_bqr.h

+5 −5
Original line number Diff line number Diff line
@@ -20,7 +20,8 @@ 
#include <bluetooth/log.h>



#include "btm_api_types.h"

#include "common/leaky_bonded_queue.h"

#include "common/postable_context.h"

#include "hci/hci_packets.h"

#include "include/hardware/bt_bqr.h"

#include "osi/include/osi.h"

#include "raw_address.h"
@@ -412,9 +413,8 @@ std::string PacketTypeToString(uint8_t packet_type); 
// And the minimum time interval of quality event reporting depends on the

// setting of property "persist.bluetooth.bqr.min_interval_ms".

//

// @param is_enable True/False to enable/disable Bluetooth Quality Report

//   mechanism in the Bluetooth controller.

void EnableBtQualityReport(bool is_enable);

// @param to_bind gives the postable for the callback, or null if disabling.

void EnableBtQualityReport(common::PostableContext* to_bind);



// Configure Bluetooth Quality Report setting to the Bluetooth controller.

//
@@ -426,7 +426,7 @@ void ConfigureBqr(const BqrConfiguration& bqr_config); 
//

// @param p_vsc_cmpl_params A pointer to the parameters contained in the vendor

//   specific command complete event.

void BqrVscCompleteCallback(tBTM_VSC_CMPL* p_vsc_cmpl_params);

void BqrVscCompleteCallback(hci::CommandCompleteView complete);



// Invoked on completion of Bluetooth Quality Report configuration. Then it will

// Register/Unregister for receiving VSE - Bluetooth Quality Report sub-event.

system/btif/src/btif_bqr.cc

+95 −42
Original line number Diff line number Diff line
@@ -22,21 +22,28 @@ 
#include <sys/stat.h>



#include <cerrno>

#include <cstdint>



#include "btif/include/stack_manager_t.h"

#include "btif_bqr.h"

#include "btif_common.h"

#include "btif_storage.h"

#include "btm_api.h"

#include "btm_ble_api.h"

#include "common/leaky_bonded_queue.h"

#include "common/postable_context.h"

#include "common/time_util.h"

#include "core_callbacks.h"

#include "hci/hci_interface.h"

#include "hci/hci_packets.h"

#include "hci/vendor_specific_event_manager_interface.h"

#include "internal_include/bt_trace.h"

#include "main/shim/entry.h"

#include "osi/include/properties.h"

#include "packet/raw_builder.h"

#include "raw_address.h"

#include "stack/btm/btm_dev.h"

#include "stack/include/bt_types.h"

#include "stack/include/btm_api.h"

#include "stack/include/btm_ble_api.h"



namespace bluetooth {

namespace bqr {
@@ -45,8 +52,7 @@ using bluetooth::common::LeakyBondedQueue; 
using std::chrono::system_clock;



// The instance of BQR event queue

static std::unique_ptr<LeakyBondedQueue<BqrVseSubEvt>> kpBqrEventQueue(

    new LeakyBondedQueue<BqrVseSubEvt>(kBqrEventQueueSize));

static LeakyBondedQueue<BqrVseSubEvt> kpBqrEventQueue{kBqrEventQueueSize};



static uint16_t vendor_cap_supported_version;
@@ -66,6 +72,10 @@ static tBTM_BT_QUALITY_REPORT_RECEIVER* p_bqr_report_receiver_ = nullptr; 
typedef void(tBTM_VS_EVT_CB)(uint8_t len, const uint8_t* p);

tBTM_VS_EVT_CB* p_vend_spec_cb[BTM_MAX_VSE_CALLBACKS];



namespace {

common::PostableContext* to_bind_ = nullptr;

}



void BqrVseSubEvt::ParseBqrLinkQualityEvt(uint8_t length,

                                          const uint8_t* p_param_buf) {

  if (length < kLinkQualityParamTotalLen) {
@@ -332,8 +342,14 @@ std::string PacketTypeToString(uint8_t packet_type) { 
  }

}



void EnableBtQualityReport(bool is_enable) {

  log::info("is_enable: {}", is_enable);

void register_vse();

void unregister_vse();



void EnableBtQualityReport(common::PostableContext* to_bind) {

  log::info("is_enable: {}", to_bind != nullptr);

  if (to_bind != nullptr) {

    to_bind_ = to_bind;

  }



  char bqr_prop_evtmask[PROPERTY_VALUE_MAX] = {0};

  char bqr_prop_interval_ms[PROPERTY_VALUE_MAX] = {0};
@@ -356,7 +372,7 @@ void EnableBtQualityReport(bool is_enable) { 


  BqrConfiguration bqr_config = {};



  if (is_enable) {

  if (to_bind) {

    bqr_config.report_action = REPORT_ACTION_ADD;

    bqr_config.quality_event_mask =

        static_cast<uint32_t>(atoi(bqr_prop_evtmask));
@@ -368,6 +384,8 @@ void EnableBtQualityReport(bool is_enable) { 
        static_cast<uint32_t>(atoi(bqr_prop_vnd_trace_mask));

    bqr_config.report_interval_multiple =

        static_cast<uint32_t>(atoi(bqr_prop_interval_multiple));

    register_vse();

    kpBqrEventQueue.Clear();

  } else {

    bqr_config.report_action = REPORT_ACTION_CLEAR;

    bqr_config.quality_event_mask = kQualityEventMaskAllOff;
@@ -375,6 +393,7 @@ void EnableBtQualityReport(bool is_enable) { 
    bqr_config.vnd_quality_mask = 0;

    bqr_config.vnd_trace_mask = 0;

    bqr_config.report_interval_multiple = 0;

    unregister_vse();

  }



  tBTM_BLE_VSC_CB cmn_vsc_cb;
@@ -419,24 +438,33 @@ void ConfigureBqr(const BqrConfiguration& bqr_config) { 
            bqr_config.minimum_report_interval_ms,

            bqr_config.report_interval_multiple);



  uint8_t param[sizeof(BqrConfiguration)];

  uint8_t* p_param = param;

  UINT8_TO_STREAM(p_param, bqr_config.report_action);

  UINT32_TO_STREAM(p_param, bqr_config.quality_event_mask);

  UINT16_TO_STREAM(p_param, bqr_config.minimum_report_interval_ms);

  auto payload = std::make_unique<packet::RawBuilder>();

  payload->AddOctets1(bqr_config.report_action);

  payload->AddOctets4(bqr_config.quality_event_mask);

  payload->AddOctets2(bqr_config.minimum_report_interval_ms);

  if (vendor_cap_supported_version >= kBqrVndLogVersion) {

    UINT32_TO_STREAM(p_param, bqr_config.vnd_quality_mask);

    UINT32_TO_STREAM(p_param, bqr_config.vnd_trace_mask);

    payload->AddOctets4(bqr_config.vnd_quality_mask);

    payload->AddOctets4(bqr_config.vnd_trace_mask);

  }

  if (vendor_cap_supported_version >= kBqrVersion6_0) {

    UINT32_TO_STREAM(p_param, bqr_config.report_interval_multiple);

    payload->AddOctets4(bqr_config.report_interval_multiple);

  }



  BTM_VendorSpecificCommand(HCI_CONTROLLER_BQR, p_param - param, param,

                            BqrVscCompleteCallback);

  shim::GetHciLayer()->EnqueueCommand(

      hci::CommandBuilder::Create(hci::OpCode::CONTROLLER_BQR,

                                  std::move(payload)),

      to_bind_->BindOnce(BqrVscCompleteCallback));

}



void BqrVscCompleteCallback(tBTM_VSC_CMPL* p_vsc_cmpl_params) {

void BqrVscCompleteCallback(bluetooth::hci::CommandCompleteView complete) {

  std::vector<uint8_t> payload_vector{complete.GetPayload().begin(),

                                      complete.GetPayload().end()};

  tBTM_VSC_CMPL vsc_cmpl_params = {

      .opcode = static_cast<uint16_t>(complete.GetCommandOpCode()),

      .param_len = static_cast<uint16_t>(payload_vector.size()),

      .p_param_buf = payload_vector.data()};

  tBTM_VSC_CMPL* p_vsc_cmpl_params = &vsc_cmpl_params;



  if (p_vsc_cmpl_params->param_len < 1) {

    log::error("The length of returned parameters is less than 1");

    return;
@@ -497,9 +525,7 @@ void BqrVscCompleteCallback(tBTM_VSC_CMPL* p_vsc_cmpl_params) { 
}



void ConfigBqrA2dpScoThreshold() {

  uint8_t param[20] = {0};

  uint8_t sub_opcode = 0x16;

  uint8_t* p_param = param;

  uint16_t a2dp_choppy_threshold = 0;

  uint16_t sco_choppy_threshold = 0;
@@ -512,26 +538,28 @@ void ConfigBqrA2dpScoThreshold() { 
  log::warn("a2dp_choppy_threshold: {}, sco_choppy_threshold: {}",

            a2dp_choppy_threshold, sco_choppy_threshold);



  UINT8_TO_STREAM(p_param, sub_opcode);

  auto payload = std::make_unique<packet::RawBuilder>();

  payload->AddOctets1(sub_opcode);



  // A2dp glitch ID

  UINT8_TO_STREAM(p_param, QUALITY_REPORT_ID_A2DP_AUDIO_CHOPPY);

  payload->AddOctets1(QUALITY_REPORT_ID_A2DP_AUDIO_CHOPPY);

  // A2dp glitch config data length

  UINT8_TO_STREAM(p_param, 2);

  payload->AddOctets1(2);

  // A2dp glitch threshold

  UINT16_TO_STREAM(p_param,

                   a2dp_choppy_threshold == 0 ? 1 : a2dp_choppy_threshold);

  payload->AddOctets2(a2dp_choppy_threshold == 0 ? 1 : a2dp_choppy_threshold);



  // Sco glitch ID

  UINT8_TO_STREAM(p_param, QUALITY_REPORT_ID_SCO_VOICE_CHOPPY);

  payload->AddOctets1(QUALITY_REPORT_ID_SCO_VOICE_CHOPPY);

  // Sco glitch config data length

  UINT8_TO_STREAM(p_param, 2);

  payload->AddOctets1(2);

  // Sco glitch threshold

  UINT16_TO_STREAM(p_param,

                   sco_choppy_threshold == 0 ? 1 : sco_choppy_threshold);

  payload->AddOctets2(sco_choppy_threshold == 0 ? 1 : sco_choppy_threshold);



  BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE, p_param - param, param,

                            NULL);

  shim::GetHciLayer()->EnqueueCommand(

      hci::CommandBuilder::Create(

          static_cast<bluetooth::hci::OpCode>(HCI_VS_HOST_LOG_OPCODE),

          std::move(payload)),

      to_bind_->BindOnce([](hci::CommandCompleteView) {}));

}



static tBTM_STATUS BTM_BT_Quality_Report_VSE_Register(
@@ -677,7 +705,7 @@ void AddLinkQualityEventToQueue(uint8_t length, 
    log::warn("failed to deliver BQR, bqrItf is NULL");

  }



  kpBqrEventQueue->Enqueue(p_bqr_event.release());

  kpBqrEventQueue.Enqueue(p_bqr_event.release());

}



void DumpLmpLlMessage(uint8_t length, const uint8_t* p_lmp_ll_message_event) {
@@ -751,13 +779,13 @@ int OpenBtSchedulingTraceLogFile() { 
void DebugDump(int fd) {

  dprintf(fd, "\nBT Quality Report Events: \n");



  if (kpBqrEventQueue->Empty()) {

  if (kpBqrEventQueue.Empty()) {

    dprintf(fd, "Event queue is empty.\n");

    return;

  }



  while (!kpBqrEventQueue->Empty()) {

    std::unique_ptr<BqrVseSubEvt> p_event(kpBqrEventQueue->Dequeue());

  while (!kpBqrEventQueue.Empty()) {

    std::unique_ptr<BqrVseSubEvt> p_event(kpBqrEventQueue.Dequeue());



    bool warning = (p_event->bqr_link_quality_event_.rssi < kCriWarnRssi ||

                    p_event->bqr_link_quality_event_.unused_afh_channel_count >
@@ -1002,14 +1030,14 @@ tBTM_STATUS BTM_BT_Quality_Report_VSE_Register( 
 *

 ******************************************************************************/

void btm_vendor_specific_evt(const uint8_t* p, uint8_t evt_len) {

  uint8_t sub_event_code = HCI_VSE_SUBCODE_BQR_SUB_EVT;

  uint8_t quality_report_id = *p;

  uint8_t bqr_parameter_length = evt_len;

  const uint8_t* p_bqr_event = p;



  log::verbose("BTM Event: Vendor Specific event from controller");



  // The stream currently points to the BQR sub-event parameters

  switch (sub_event_code) {

  switch (quality_report_id) {

    case bluetooth::bqr::QUALITY_REPORT_ID_LMP_LL_MESSAGE_TRACE:

      if (bqr_parameter_length >= bluetooth::bqr::kLogDumpParamTotalLen) {

        bluetooth::bqr::DumpLmpLlMessage(bqr_parameter_length, p_bqr_event);
@@ -1028,17 +1056,15 @@ void btm_vendor_specific_evt(const uint8_t* p, uint8_t evt_len) { 
      break;



    default:

      log::info("Unhandled BQR subevent 0x{:02x}", sub_event_code);

      log::info("Unhandled BQR subevent 0x{:02x}", quality_report_id);

  }



  uint8_t i;

  std::vector<uint8_t> reconstructed_event;

  reconstructed_event.reserve(4 + bqr_parameter_length);

  reconstructed_event[0] = HCI_VENDOR_SPECIFIC_EVT;

  reconstructed_event[1] = 3 + bqr_parameter_length;  // event size

  reconstructed_event[2] = HCI_VSE_SUBCODE_BQR_SUB_EVT;

  reconstructed_event.push_back(HCI_VSE_SUBCODE_BQR_SUB_EVT);

  for (i = 0; i < bqr_parameter_length; i++) {

    reconstructed_event.push_back(p[i]);

    reconstructed_event.push_back(p_bqr_event[i]);

  }



  for (i = 0; i < BTM_MAX_VSE_CALLBACKS; i++) {
@@ -1048,5 +1074,32 @@ void btm_vendor_specific_evt(const uint8_t* p, uint8_t evt_len) { 
  }

}



static void vendor_specific_event_callback(

    bluetooth::hci::VendorSpecificEventView vendor_specific_event_view) {

  auto bqr =

      bluetooth::hci::BqrEventView::CreateOptional(vendor_specific_event_view);

  if (!bqr) {

    return;

  }

  auto payload = vendor_specific_event_view.GetPayload();

  std::vector<uint8_t> bytes{payload.begin(), payload.end()};

  btm_vendor_specific_evt(bytes.data(), bytes.size());

}



void register_vse() {

  bluetooth::shim::GetVendorSpecificEventManager()->RegisterEventHandler(

      bluetooth::hci::VseSubeventCode::BQR_EVENT,

      to_bind_->Bind(vendor_specific_event_callback));

}



void unregister_vse() {

  bluetooth::shim::GetVendorSpecificEventManager()->UnregisterEventHandler(

      hci::VseSubeventCode::BQR_EVENT);

}



namespace testing {

void set_lmp_trace_log_fd(int fd) { LmpLlMessageTraceLogFd = fd; }

}  // namespace testing



}  // namespace bqr

}  // namespace bluetooth

system/btif/src/btif_dm.cc

+2 −2
Original line number Diff line number Diff line
@@ -2167,7 +2167,7 @@ void BTIF_dm_enable() { 
  ** and bonded_devices_info_cb

  */

  btif_storage_load_bonded_devices();

  bluetooth::bqr::EnableBtQualityReport(true);

  bluetooth::bqr::EnableBtQualityReport(get_main());

  btif_enable_bluetooth_evt();

}
@@ -2184,7 +2184,7 @@ void BTIF_dm_disable() { 
      btif_in_execute_service_request(i, false);

    }

  }

  bluetooth::bqr::EnableBtQualityReport(false);

  bluetooth::bqr::EnableBtQualityReport(nullptr);

  log::info("Stack device manager shutdown finished");

  future_ready(stack_manager_get_hack_future(), FUTURE_SUCCESS);

}

system/btif/test/btif_core_test.cc

+395 −1

File changed.

Preview size limit exceeded, changes collapsed.