Merge changes from topic "revert-3074206-HETWXZTPUZ" into main am: 52a1876f74 (d2acff6e) · Commits · e / os / android_packages_modules_Bluetooth

system/btif/Android.bp

+0 −2

Original line number	Diff line number	Diff line
		@@ -735,7 +735,6 @@ cc_test {
		"libbluetooth-types",
		"libbluetooth_crypto_toolbox",
		"libbluetooth_gd",
		"libbluetooth_hci_pdl",
		"libbluetooth_log",
		"libbt-audio-hal-interface",
		"libbt-btu-main-thread",
		@@ -753,7 +752,6 @@ cc_test {
		"libchrome",
		"libcom.android.sysprop.bluetooth.wrapped",
		"libevent",
		"libflatbuffers-cpp",
		"libgmock",
		"libprotobuf-cpp-lite",
		"libstatslog_bt",

system/btif/include/btif_bqr.h

+76 −4

Original line number	Diff line number	Diff line
		@@ -19,8 +19,8 @@

		#include <bluetooth/log.h>

		#include "common/postable_context.h"
		#include "hci/hci_packets.h"
		#include "btm_api_types.h"
		#include "common/leaky_bonded_queue.h"
		#include "include/hardware/bt_bqr.h"
		#include "osi/include/osi.h"
		#include "raw_address.h"
		@@ -393,6 +393,18 @@ class BqrVseSubEvt {

		BluetoothQualityReportInterface* getBluetoothQualityReportInterface();

		// Get a string representation of the Quality Report ID.
		//
		// @param quality_report_id The quality report ID to convert.
		// @return a string representation of the Quality Report ID.
		std::string QualityReportIdToString(uint8_t quality_report_id);

		// Get a string representation of the Packet Type.
		//
		// @param packet_type The packet type to convert.
		// @return a string representation of the Packet Type.
		std::string PacketTypeToString(uint8_t packet_type);

		// Enable/Disable Bluetooth Quality Report mechanism.
		//
		// Which Quality event will be enabled is according to the setting of the
		@@ -400,8 +412,68 @@ BluetoothQualityReportInterface* getBluetoothQualityReportInterface();
		// And the minimum time interval of quality event reporting depends on the
		// setting of property "persist.bluetooth.bqr.min_interval_ms".
		//
		// @param to_bind gives the postable for the callback, or null if disabling.
		void EnableBtQualityReport(common::PostableContext* to_bind);
		// @param is_enable True/False to enable/disable Bluetooth Quality Report
		// mechanism in the Bluetooth controller.
		void EnableBtQualityReport(bool is_enable);

		// Configure Bluetooth Quality Report setting to the Bluetooth controller.
		//
		// @param bqr_config The struct of configuration parameters.
		void ConfigureBqr(const BqrConfiguration& bqr_config);

		// Callback invoked on completion of vendor specific Bluetooth Quality Report
		// command.
		//
		// @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);

		// Invoked on completion of Bluetooth Quality Report configuration. Then it will
		// Register/Unregister for receiving VSE - Bluetooth Quality Report sub-event.
		//
		// @param current_evt_mask Indicates current quality event bit mask setting in
		// the Bluetooth controller.
		void ConfigureBqrCmpl(uint32_t current_evt_mask);

		// Categorize the incoming Bluetooth Quality Report.
		//
		// @param length Lengths of the quality report sent from the Bluetooth
		// controller.
		// @param p_bqr_event A pointer to the BQR VSE sub-event which is sent from the
		// Bluetooth controller.
		void CategorizeBqrEvent(uint8_t length, const uint8_t* p_bqr_event);

		// Record a new incoming Link Quality related BQR event in quality event queue.
		//
		// @param length Lengths of the Link Quality related BQR event.
		// @param p_link_quality_event A pointer to the Link Quality related BQR event.
		void AddLinkQualityEventToQueue(uint8_t length,
		const uint8_t* p_link_quality_event);

		// Dump the LMP/LL message handshaking with the remote device to a log file.
		//
		// @param length Lengths of the LMP/LL message trace event.
		// @param p_lmp_ll_message_event A pointer to the LMP/LL message trace event.
		void DumpLmpLlMessage(uint8_t length, const uint8_t* p_lmp_ll_message_event);

		// Open the LMP/LL message trace log file.
		//
		// @return a file descriptor of the LMP/LL message trace log file.
		int OpenLmpLlTraceLogFile();

		// Dump the Bluetooth Multi-profile/Coex scheduling information to a log file.
		//
		// @param length Lengths of the Bluetooth Multi-profile/Coex scheduling trace
		// event.
		// @param p_bt_scheduling_event A pointer to the Bluetooth Multi-profile/Coex
		// scheduling trace event.
		void DumpBtScheduling(uint8_t length, const uint8_t* p_bt_scheduling_event);

		// Open the Bluetooth Multi-profile/Coex scheduling trace log file.
		//
		// @return a file descriptor of the Bluetooth Multi-profile/Coex scheduling
		// trace log file.
		int OpenBtSchedulingTraceLogFile();

		// Dump Bluetooth Quality Report information.
		//

system/btif/src/btif_bqr.cc

+54 −192

Original line number	Diff line number	Diff line
		@@ -14,36 +14,30 @@
		* limitations under the License.
		*/

		#include <bluetooth/log.h>
		#include <fcntl.h>
		#ifdef __ANDROID__
		#include <statslog_bt.h>
		#endif
		#include <bluetooth/log.h>
		#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/init_flags.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 {
		@@ -52,17 +46,14 @@ using bluetooth::common::LeakyBondedQueue;
		using std::chrono::system_clock;

		// The instance of BQR event queue
		static std::unique_ptr<LeakyBondedQueue<BqrVseSubEvt>> kpBqrEventQueue;
		static std::unique_ptr<LeakyBondedQueue<BqrVseSubEvt>> kpBqrEventQueue(
		new LeakyBondedQueue<BqrVseSubEvt>(kBqrEventQueueSize));

		static uint16_t vendor_cap_supported_version;

		class BluetoothQualityReportInterfaceImpl;
		std::unique_ptr<BluetoothQualityReportInterface> bluetoothQualityReportInstance;

		namespace {
		common::PostableContext* to_bind_ = nullptr;
		}

		void BqrVseSubEvt::ParseBqrLinkQualityEvt(uint8_t length,
		const uint8_t* p_param_buf) {
		if (length < kLinkQualityParamTotalLen) {
		@@ -198,9 +189,6 @@ void BqrVseSubEvt::WriteBtSchedulingTraceLogFile(int fd, uint8_t length,
		BtSchedulingTraceCounter++;
		}

		static std::string QualityReportIdToString(uint8_t quality_report_id);
		static std::string PacketTypeToString(uint8_t packet_type);

		std::string BqrVseSubEvt::ToString() const {
		std::stringstream ss;
		ss << QualityReportIdToString(bqr_link_quality_event_.quality_report_id)
		@@ -248,11 +236,7 @@ std::string BqrVseSubEvt::ToString() const {
		return ss.str();
		}

		// Get a string representation of the Quality Report ID.
		//
		// @param quality_report_id The quality report ID to convert.
		// @return a string representation of the Quality Report ID.
		static std::string QualityReportIdToString(uint8_t quality_report_id) {
		std::string QualityReportIdToString(uint8_t quality_report_id) {
		switch (quality_report_id) {
		case QUALITY_REPORT_ID_MONITOR_MODE:
		return "Monitoring";
		@@ -271,11 +255,7 @@ static std::string QualityReportIdToString(uint8_t quality_report_id) {
		}
		}

		// Get a string representation of the Packet Type.
		//
		// @param packet_type The packet type to convert.
		// @return a string representation of the Packet Type.
		static std::string PacketTypeToString(uint8_t packet_type) {
		std::string PacketTypeToString(uint8_t packet_type) {
		switch (packet_type) {
		case PACKET_TYPE_ID:
		return "ID";
		@@ -340,16 +320,8 @@ static std::string PacketTypeToString(uint8_t packet_type) {
		}
		}

		void register_vse();
		void unregister_vse();

		static void ConfigureBqr(const BqrConfiguration& bqr_config);

		void EnableBtQualityReport(common::PostableContext* to_bind) {
		log::info("is_enable: {}", to_bind != nullptr);
		if (to_bind != nullptr) {
		to_bind_ = to_bind;
		}
		void EnableBtQualityReport(bool is_enable) {
		log::info("is_enable: {}", is_enable);

		char bqr_prop_evtmask[PROPERTY_VALUE_MAX] = {0};
		char bqr_prop_interval_ms[PROPERTY_VALUE_MAX] = {0};
		@@ -372,7 +344,7 @@ void EnableBtQualityReport(common::PostableContext* to_bind) {

		BqrConfiguration bqr_config = {};

		if (to_bind) {
		if (is_enable) {
		bqr_config.report_action = REPORT_ACTION_ADD;
		bqr_config.quality_event_mask =
		static_cast<uint32_t>(atoi(bqr_prop_evtmask));
		@@ -384,9 +356,6 @@ void EnableBtQualityReport(common::PostableContext* to_bind) {
		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 =
		std::make_unique<LeakyBondedQueue<BqrVseSubEvt>>(kBqrEventQueueSize);
		} else {
		bqr_config.report_action = REPORT_ACTION_CLEAR;
		bqr_config.quality_event_mask = kQualityEventMaskAllOff;
		@@ -394,7 +363,6 @@ void EnableBtQualityReport(common::PostableContext* to_bind) {
		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;
		@@ -409,11 +377,6 @@ void EnableBtQualityReport(common::PostableContext* to_bind) {
		ConfigureBqr(bqr_config);
		}

		static void BqrVscCompleteCallback(hci::CommandCompleteView complete);

		// Configure Bluetooth Quality Report setting to the Bluetooth controller.
		//
		// @param bqr_config The struct of configuration parameters.
		void ConfigureBqr(const BqrConfiguration& bqr_config) {
		if (vendor_cap_supported_version >= kBqrVersion6_0) {
		if (bqr_config.report_action > REPORT_ACTION_QUERY \|\|
		@@ -444,40 +407,24 @@ void ConfigureBqr(const BqrConfiguration& bqr_config) {
		bqr_config.minimum_report_interval_ms,
		bqr_config.report_interval_multiple);

		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);
		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);
		if (vendor_cap_supported_version >= kBqrVndLogVersion) {
		payload->AddOctets4(bqr_config.vnd_quality_mask);
		payload->AddOctets4(bqr_config.vnd_trace_mask);
		UINT32_TO_STREAM(p_param, bqr_config.vnd_quality_mask);
		UINT32_TO_STREAM(p_param, bqr_config.vnd_trace_mask);
		}
		if (vendor_cap_supported_version >= kBqrVersion6_0) {
		payload->AddOctets4(bqr_config.report_interval_multiple);
		UINT32_TO_STREAM(p_param, bqr_config.report_interval_multiple);
		}

		shim::GetHciLayer()->EnqueueCommand(
		hci::CommandBuilder::Create(hci::OpCode::CONTROLLER_BQR,
		std::move(payload)),
		to_bind_->BindOnce(BqrVscCompleteCallback));
		BTM_VendorSpecificCommand(HCI_CONTROLLER_BQR, p_param - param, param,
		BqrVscCompleteCallback);
		}

		static void ConfigureBqrCmpl(uint32_t current_evt_mask);

		// Callback invoked on completion of vendor specific Bluetooth Quality Report
		// command.
		//
		// @param p_vsc_cmpl_params A pointer to the parameters contained in the vendor
		// specific command complete event.
		static void BqrVscCompleteCallback(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;

		void BqrVscCompleteCallback(tBTM_VSC_CMPL* p_vsc_cmpl_params) {
		if (p_vsc_cmpl_params->param_len < 1) {
		log::error("The length of returned parameters is less than 1");
		return;
		@@ -538,7 +485,9 @@ static void BqrVscCompleteCallback(hci::CommandCompleteView complete) {
		}

		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;

		@@ -548,44 +497,47 @@ void ConfigBqrA2dpScoThreshold() {
		sscanf(bqr_prop_threshold, "%hu,%hu", &a2dp_choppy_threshold,
		&sco_choppy_threshold);

		log::info("a2dp_choppy_threshold: {}, sco_choppy_threshold: {}",
		log::warn("a2dp_choppy_threshold: {}, sco_choppy_threshold: {}",
		a2dp_choppy_threshold, sco_choppy_threshold);

		auto payload = std::make_unique<packet::RawBuilder>();
		payload->AddOctets1(sub_opcode);
		UINT8_TO_STREAM(p_param, sub_opcode);

		// A2dp glitch ID
		payload->AddOctets1(QUALITY_REPORT_ID_A2DP_AUDIO_CHOPPY);
		UINT8_TO_STREAM(p_param, QUALITY_REPORT_ID_A2DP_AUDIO_CHOPPY);
		// A2dp glitch config data length
		payload->AddOctets1(2);
		UINT8_TO_STREAM(p_param, 2);
		// A2dp glitch threshold
		payload->AddOctets2(a2dp_choppy_threshold == 0 ? 1 : a2dp_choppy_threshold);
		UINT16_TO_STREAM(p_param,
		a2dp_choppy_threshold == 0 ? 1 : a2dp_choppy_threshold);

		// Sco glitch ID
		payload->AddOctets1(QUALITY_REPORT_ID_SCO_VOICE_CHOPPY);
		UINT8_TO_STREAM(p_param, QUALITY_REPORT_ID_SCO_VOICE_CHOPPY);
		// Sco glitch config data length
		payload->AddOctets1(2);
		UINT8_TO_STREAM(p_param, 2);
		// Sco glitch threshold
		payload->AddOctets2(sco_choppy_threshold == 0 ? 1 : sco_choppy_threshold);
		UINT16_TO_STREAM(p_param,
		sco_choppy_threshold == 0 ? 1 : sco_choppy_threshold);

		shim::GetHciLayer()->EnqueueCommand(
		hci::CommandBuilder::Create(
		static_cast<hci::OpCode>(HCI_VS_HOST_LOG_OPCODE), std::move(payload)),
		to_bind_->BindOnce([](hci::CommandCompleteView) {}));
		BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE, p_param - param, param,
		NULL);
		}

		// Invoked on completion of Bluetooth Quality Report configuration. Then it will
		// Register/Unregister for receiving VSE - Bluetooth Quality Report sub-event.
		//
		// @param current_evt_mask Indicates current quality event bit mask setting in
		// the Bluetooth controller.
		static void ConfigureBqrCmpl(uint32_t current_evt_mask) {
		void ConfigureBqrCmpl(uint32_t current_evt_mask) {
		log::info("current_evt_mask: 0x{:x}", current_evt_mask);
		// (Un)Register for VSE of Bluetooth Quality Report sub event
		tBTM_STATUS btm_status = BTM_BT_Quality_Report_VSE_Register(
		current_evt_mask > kQualityEventMaskAllOff, CategorizeBqrEvent);

		if (current_evt_mask > kQualityEventMaskAllOff) {
		ConfigBqrA2dpScoThreshold();
		}

		if (btm_status != BTM_SUCCESS) {
		log::error("Fail to (un)register VSE of BQR sub event. status: {}",
		btm_status);
		return;
		}

		if (LmpLlMessageTraceLogFd != INVALID_FD &&
		(current_evt_mask & kQualityEventMaskLmpMessageTrace) == 0) {
		log::info("Closing LMP/LL log file.");
		@@ -600,15 +552,7 @@ static void ConfigureBqrCmpl(uint32_t current_evt_mask) {
		}
		}

		static void AddLinkQualityEventToQueue(uint8_t length,
		const uint8_t* p_link_quality_event);
		// Categorize the incoming Bluetooth Quality Report.
		//
		// @param length Lengths of the quality report sent from the Bluetooth
		// controller.
		// @param p_bqr_event A pointer to the BQR VSE sub-event which is sent from the
		// Bluetooth controller.
		static void CategorizeBqrEvent(uint8_t length, const uint8_t* p_bqr_event) {
		void CategorizeBqrEvent(uint8_t length, const uint8_t* p_bqr_event) {
		if (length == 0) {
		log::warn("Lengths of all of the parameters are zero.");
		return;
		@@ -650,17 +594,14 @@ static void CategorizeBqrEvent(uint8_t length, const uint8_t* p_bqr_event) {
		}
		}

		// Record a new incoming Link Quality related BQR event in quality event queue.
		//
		// @param length Lengths of the Link Quality related BQR event.
		// @param p_link_quality_event A pointer to the Link Quality related BQR event.
		static void AddLinkQualityEventToQueue(uint8_t length,
		void AddLinkQualityEventToQueue(uint8_t length,
		const uint8_t* p_link_quality_event) {
		std::unique_ptr<BqrVseSubEvt> p_bqr_event = std::make_unique<BqrVseSubEvt>();
		RawAddress bd_addr;

		p_bqr_event->ParseBqrLinkQualityEvt(length, p_link_quality_event);

		log::warn("{}", *p_bqr_event);
		GetInterfaceToProfiles()->events->invoke_link_quality_report_cb(
		bluetooth::common::time_get_os_boottime_ms(),
		p_bqr_event->bqr_link_quality_event_.quality_report_id,
		@@ -724,14 +665,7 @@ static void AddLinkQualityEventToQueue(uint8_t length,
		kpBqrEventQueue->Enqueue(p_bqr_event.release());
		}

		static int OpenLmpLlTraceLogFile();

		// Dump the LMP/LL message handshaking with the remote device to a log file.
		//
		// @param length Lengths of the LMP/LL message trace event.
		// @param p_lmp_ll_message_event A pointer to the LMP/LL message trace event.
		static void DumpLmpLlMessage(uint8_t length,
		const uint8_t* p_lmp_ll_message_event) {
		void DumpLmpLlMessage(uint8_t length, const uint8_t* p_lmp_ll_message_event) {
		std::unique_ptr<BqrVseSubEvt> p_bqr_event = std::make_unique<BqrVseSubEvt>();

		if (LmpLlMessageTraceLogFd == INVALID_FD \|\|
		@@ -744,10 +678,7 @@ static void DumpLmpLlMessage(uint8_t length,
		}
		}

		// Open the LMP/LL message trace log file.
		//
		// @return a file descriptor of the LMP/LL message trace log file.
		static int OpenLmpLlTraceLogFile() {
		int OpenLmpLlTraceLogFile() {
		if (rename(kpLmpLlMessageTraceLogPath, kpLmpLlMessageTraceLastLogPath) != 0 &&
		errno != ENOENT) {
		log::error("Unable to rename '{}' to '{}' : {}", kpLmpLlMessageTraceLogPath,
		@@ -768,16 +699,7 @@ static int OpenLmpLlTraceLogFile() {
		return logfile_fd;
		}

		static int OpenBtSchedulingTraceLogFile();

		// Dump the Bluetooth Multi-profile/Coex scheduling information to a log file.
		//
		// @param length Lengths of the Bluetooth Multi-profile/Coex scheduling trace
		// event.
		// @param p_bt_scheduling_event A pointer to the Bluetooth Multi-profile/Coex
		// scheduling trace event.
		static void DumpBtScheduling(uint8_t length,
		const uint8_t* p_bt_scheduling_event) {
		void DumpBtScheduling(uint8_t length, const uint8_t* p_bt_scheduling_event) {
		std::unique_ptr<BqrVseSubEvt> p_bqr_event = std::make_unique<BqrVseSubEvt>();

		if (BtSchedulingTraceLogFd == INVALID_FD \|\|
		@@ -790,11 +712,7 @@ static void DumpBtScheduling(uint8_t length,
		}
		}

		// Open the Bluetooth Multi-profile/Coex scheduling trace log file.
		//
		// @return a file descriptor of the Bluetooth Multi-profile/Coex scheduling
		// trace log file.
		static int OpenBtSchedulingTraceLogFile() {
		int OpenBtSchedulingTraceLogFile() {
		if (rename(kpBtSchedulingTraceLogPath, kpBtSchedulingTraceLastLogPath) != 0 &&
		errno != ENOENT) {
		log::error("Unable to rename '{}' to '{}' : {}", kpBtSchedulingTraceLogPath,
		@@ -941,61 +859,5 @@ BluetoothQualityReportInterface* getBluetoothQualityReportInterface() {
		return bluetoothQualityReportInstance.get();
		}

		static void vendor_specific_event_callback(
		hci::VendorSpecificEventView vendor_specific_event_view) {
		auto bqr = 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()};

		uint8_t quality_report_id = static_cast<uint8_t>(bqr->GetQualityReportId());
		uint8_t bqr_parameter_length = bytes.size();
		const uint8_t* p_bqr_event = bytes.data();

		// The stream currently points to the BQR sub-event parameters
		switch (quality_report_id) {
		case bluetooth::bqr::QUALITY_REPORT_ID_LMP_LL_MESSAGE_TRACE: {
		auto lmp_view = hci::BqrLogDumpEventView::Create(*bqr);
		}
		if (bqr_parameter_length >= bluetooth::bqr::kLogDumpParamTotalLen) {
		bluetooth::bqr::DumpLmpLlMessage(bqr_parameter_length, p_bqr_event);
		} else {
		log::info("Malformed LMP event of length {}", bqr_parameter_length);
		}

		break;

		case bluetooth::bqr::QUALITY_REPORT_ID_BT_SCHEDULING_TRACE:
		if (bqr_parameter_length >= bluetooth::bqr::kLogDumpParamTotalLen) {
		bluetooth::bqr::DumpBtScheduling(bqr_parameter_length, p_bqr_event);
		} else {
		log::info("Malformed TRACE event of length {}", bqr_parameter_length);
		}
		break;

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

		CategorizeBqrEvent(bytes.size(), bytes.data());
		}

		void register_vse() {
		bluetooth::shim::GetVendorSpecificEventManager()->RegisterEventHandler(
		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(get_main());
		bluetooth::bqr::EnableBtQualityReport(true);
		btif_enable_bluetooth_evt();
		}

		@@ -2184,7 +2184,7 @@ void BTIF_dm_disable() {
		btif_in_execute_service_request(i, false);
		}
		}
		bluetooth::bqr::EnableBtQualityReport(nullptr);
		bluetooth::bqr::EnableBtQualityReport(false);
		log::info("Stack device manager shutdown finished");
		future_ready(stack_manager_get_hack_future(), FUTURE_SUCCESS);
		}

system/btif/test/btif_core_test.cc

+1 −367

File changed.

Preview size limit exceeded, changes collapsed.