Merge changes I098fe24f,I9840e87b into main (d3ba2297) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/hearing_aid/hearing_aid.cc

+254 −265

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/hearing_aid/hearing_aid_audio_source.cc

+47 −31

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include <base/files/file_util.h>
		#include <base/logging.h>
		#include <bluetooth/log.h>

		#include <cstdint>
		#include <memory>
		@@ -35,6 +36,20 @@
		#include "udrv/include/uipc.h"

		using base::FilePath;
		using namespace bluetooth;

		namespace fmt {
		template <>
		struct formatter<bt_status_t> : enum_formatter<bt_status_t> {};
		template <>
		struct formatter<tUIPC_EVENT> : enum_formatter<tUIPC_EVENT> {};
		template <>
		struct formatter<tHEARING_AID_CTRL_ACK>
		: enum_formatter<tHEARING_AID_CTRL_ACK> {};
		template <>
		struct formatter<tHEARING_AID_CTRL_CMD>
		: enum_formatter<tHEARING_AID_CTRL_CMD> {};
		} // namespace fmt

		namespace {
		#define CASE_RETURN_STR(const) \
		@@ -100,7 +115,7 @@ void send_audio_data() {
		bytes_per_tick);
		}

		LOG_DEBUG("bytes_read: %u", bytes_read);
		log::debug("bytes_read: {}", bytes_read);
		if (bytes_read < bytes_per_tick) {
		stats.media_read_total_underflow_bytes += bytes_per_tick - bytes_read;
		stats.media_read_total_underflow_count++;
		@@ -117,34 +132,34 @@ void send_audio_data() {

		void hearing_aid_send_ack(tHEARING_AID_CTRL_ACK status) {
		uint8_t ack = status;
		LOG_DEBUG("Hearing Aid audio ctrl ack: %u", status);
		log::debug("Hearing Aid audio ctrl ack: {}", status);
		UIPC_Send(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL, 0, &ack, sizeof(ack));
		}

		void start_audio_ticks() {
		if (data_interval_ms != HA_INTERVAL_10_MS &&
		data_interval_ms != HA_INTERVAL_20_MS) {
		LOG_ALWAYS_FATAL("Unsupported data interval: %d", data_interval_ms);
		log::fatal("Unsupported data interval: {}", data_interval_ms);
		}

		wakelock_acquire();
		audio_timer.SchedulePeriodic(get_main_thread()->GetWeakPtr(), FROM_HERE,
		base::BindRepeating(&send_audio_data),
		std::chrono::milliseconds(data_interval_ms));
		LOG_INFO("running with data interval: %d", data_interval_ms);
		log::info("running with data interval: {}", data_interval_ms);
		}

		void stop_audio_ticks() {
		LOG_INFO("stopped");
		log::info("stopped");
		audio_timer.CancelAndWait();
		wakelock_release();
		}

		void hearing_aid_data_cb(tUIPC_CH_ID, tUIPC_EVENT event) {
		LOG_DEBUG("Hearing Aid audio data event: %u", event);
		log::debug("Hearing Aid audio data event: {}", event);
		switch (event) {
		case UIPC_OPEN_EVT:
		LOG_INFO("UIPC_OPEN_EVT");
		log::info("UIPC_OPEN_EVT");
		/*
		* Read directly from media task from here on (keep callback for
		* connection events.
		@@ -157,12 +172,12 @@ void hearing_aid_data_cb(tUIPC_CH_ID, tUIPC_EVENT event) {
		do_in_main_thread(FROM_HERE, base::BindOnce(start_audio_ticks));
		break;
		case UIPC_CLOSE_EVT:
		LOG_INFO("UIPC_CLOSE_EVT");
		log::info("UIPC_CLOSE_EVT");
		hearing_aid_send_ack(HEARING_AID_CTRL_ACK_SUCCESS);
		do_in_main_thread(FROM_HERE, base::BindOnce(stop_audio_ticks));
		break;
		default:
		LOG_ERROR("Hearing Aid audio data event not recognized: %u", event);
		log::error("Hearing Aid audio data event not recognized: {}", event);
		}
		}

		@@ -176,12 +191,12 @@ void hearing_aid_recv_ctrl_data() {

		/* detach on ctrl channel means audioflinger process was terminated */
		if (n == 0) {
		LOG_WARN("CTRL CH DETACHED");
		log::warn("CTRL CH DETACHED");
		UIPC_Close(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL);
		return;
		}

		LOG_INFO("%s", audio_ha_hw_dump_ctrl_event(cmd));
		log::info("{}", audio_ha_hw_dump_ctrl_event(cmd));
		// a2dp_cmd_pending = cmd;

		tHEARING_AID_CTRL_ACK ctrl_ack_status;
		@@ -205,7 +220,7 @@ void hearing_aid_recv_ctrl_data() {

		case HEARING_AID_CTRL_CMD_STOP:
		if (!hearing_aid_on_suspend_req()) {
		LOG_INFO(
		log::info(
		"HEARING_AID_CTRL_CMD_STOP: hearing_aid_on_suspend_req() errs, but "
		"ignored.");
		}
		@@ -230,7 +245,7 @@ void hearing_aid_recv_ctrl_data() {
		codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_24000;
		codec_capability.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_24000;
		} else {
		LOG_ALWAYS_FATAL("unsupported sample rate: %d", sample_rate);
		log::fatal("unsupported sample rate: {}", sample_rate);
		}

		codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16;
		@@ -278,14 +293,14 @@ void hearing_aid_recv_ctrl_data() {
		reinterpret_cast<uint8_t*>(&codec_config.sample_rate),
		sizeof(btav_a2dp_codec_sample_rate_t)) !=
		sizeof(btav_a2dp_codec_sample_rate_t)) {
		LOG_ERROR("Error reading sample rate from audio HAL");
		log::error("Error reading sample rate from audio HAL");
		break;
		}
		if (UIPC_Read(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL,
		reinterpret_cast<uint8_t*>(&codec_config.bits_per_sample),
		sizeof(btav_a2dp_codec_bits_per_sample_t)) !=
		sizeof(btav_a2dp_codec_bits_per_sample_t)) {
		LOG_ERROR("Error reading bits per sample from audio HAL");
		log::error("Error reading bits per sample from audio HAL");

		break;
		}
		@@ -293,28 +308,28 @@ void hearing_aid_recv_ctrl_data() {
		reinterpret_cast<uint8_t*>(&codec_config.channel_mode),
		sizeof(btav_a2dp_codec_channel_mode_t)) !=
		sizeof(btav_a2dp_codec_channel_mode_t)) {
		LOG_ERROR("Error reading channel mode from audio HAL");
		log::error("Error reading channel mode from audio HAL");

		break;
		}
		LOG_INFO(
		"HEARING_AID_CTRL_SET_OUTPUT_AUDIO_CONFIG: sample_rate=%u, "
		"bits_per_sample=%u,channel_mode=%u",
		log::info(
		"HEARING_AID_CTRL_SET_OUTPUT_AUDIO_CONFIG: sample_rate={}, "
		"bits_per_sample={},channel_mode={}",
		codec_config.sample_rate, codec_config.bits_per_sample,
		codec_config.channel_mode);
		break;
		}

		default:
		LOG_ERROR("UNSUPPORTED CMD: %u", cmd);
		log::error("UNSUPPORTED CMD: {}", cmd);
		hearing_aid_send_ack(HEARING_AID_CTRL_ACK_FAILURE);
		break;
		}
		LOG_INFO("a2dp-ctrl-cmd : %s DONE", audio_ha_hw_dump_ctrl_event(cmd));
		log::info("a2dp-ctrl-cmd : {} DONE", audio_ha_hw_dump_ctrl_event(cmd));
		}

		void hearing_aid_ctrl_cb(tUIPC_CH_ID, tUIPC_EVENT event) {
		LOG_DEBUG("Hearing Aid audio ctrl event: %u", event);
		log::debug("Hearing Aid audio ctrl event: {}", event);
		switch (event) {
		case UIPC_OPEN_EVT:
		break;
		@@ -329,13 +344,13 @@ void hearing_aid_ctrl_cb(tUIPC_CH_ID, tUIPC_EVENT event) {
		hearing_aid_recv_ctrl_data();
		break;
		default:
		LOG_ERROR("Hearing Aid audio ctrl unrecognized event: %u", event);
		log::error("Hearing Aid audio ctrl unrecognized event: {}", event);
		}
		}

		bool hearing_aid_on_resume_req(bool start_media_task) {
		if (localAudioReceiver == nullptr) {
		LOG_ERROR("HEARING_AID_CTRL_CMD_START: audio receiver not started");
		log::error("HEARING_AID_CTRL_CMD_START: audio receiver not started");
		return false;
		}
		bt_status_t status;
		@@ -346,7 +361,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) {
		start_audio_ticks));
		} else {
		auto start_dummy_ticks = []() {
		LOG_INFO("start_audio_ticks: waiting for data path opened");
		log::info("start_audio_ticks: waiting for data path opened");
		};
		status = do_in_main_thread(
		FROM_HERE, base::BindOnce(&HearingAidAudioReceiver::OnAudioResume,
		@@ -354,7 +369,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) {
		start_dummy_ticks));
		}
		if (status != BT_STATUS_SUCCESS) {
		LOG_ERROR("HEARING_AID_CTRL_CMD_START: do_in_main_thread err=%u", status);
		log::error("HEARING_AID_CTRL_CMD_START: do_in_main_thread err={}", status);
		return false;
		}
		return true;
		@@ -362,7 +377,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) {

		bool hearing_aid_on_suspend_req() {
		if (localAudioReceiver == nullptr) {
		LOG_ERROR("HEARING_AID_CTRL_CMD_SUSPEND: audio receiver not started");
		log::error("HEARING_AID_CTRL_CMD_SUSPEND: audio receiver not started");
		return false;
		}
		bt_status_t status = do_in_main_thread(
		@@ -370,7 +385,8 @@ bool hearing_aid_on_suspend_req() {
		base::BindOnce(&HearingAidAudioReceiver::OnAudioSuspend,
		base::Unretained(localAudioReceiver), stop_audio_ticks));
		if (status != BT_STATUS_SUCCESS) {
		LOG_ERROR("HEARING_AID_CTRL_CMD_SUSPEND: do_in_main_thread err=%u", status);
		log::error("HEARING_AID_CTRL_CMD_SUSPEND: do_in_main_thread err={}",
		status);
		return false;
		}
		return true;
		@@ -380,7 +396,7 @@ bool hearing_aid_on_suspend_req() {
		void HearingAidAudioSource::Start(const CodecConfiguration& codecConfiguration,
		HearingAidAudioReceiver* audioReceiver,
		uint16_t remote_delay_ms) {
		LOG_INFO("Hearing Aid Source Open");
		log::info("Hearing Aid Source Open");

		bit_rate = codecConfiguration.bit_rate;
		sample_rate = codecConfiguration.sample_rate;
		@@ -396,7 +412,7 @@ void HearingAidAudioSource::Start(const CodecConfiguration& codecConfiguration,
		}

		void HearingAidAudioSource::Stop() {
		LOG_INFO("Hearing Aid Source Close");
		log::info("Hearing Aid Source Close");

		localAudioReceiver = nullptr;
		if (bluetooth::audio::hearing_aid::is_hal_enabled()) {
		@@ -412,7 +428,7 @@ void HearingAidAudioSource::Initialize() {
		.on_suspend_ = hearing_aid_on_suspend_req,
		};
		if (!bluetooth::audio::hearing_aid::init(stream_cb, get_main_thread())) {
		LOG_WARN("Using legacy HAL");
		log::warn("Using legacy HAL");
		uipc_hearing_aid = UIPC_Init();
		UIPC_Open(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL, hearing_aid_ctrl_cb, HEARING_AID_CTRL_PATH);
		}

system/bta/include/bta_hearing_aid_api.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@
		#pragma once

		#include <base/functional/callback_forward.h>
		#include <bluetooth/log.h>
		#include <hardware/bt_hearing_aid.h>

		#include <cstdint>
		@@ -286,3 +287,9 @@ class HearingAidAudioSource {
		static void CleanUp();
		static void DebugDump(int fd);
		};

		namespace fmt {
		template <>
		struct formatter<connection_update_status_t>
		: enum_formatter<connection_update_status_t> {};
		} // namespace fmt

system/bta/jv/bta_jv_act.cc

+131 −142

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/jv/bta_jv_api.cc

+30 −29

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <base/functional/bind.h>
		#include <base/location.h>
		#include <base/logging.h>
		#include <bluetooth/log.h>

		#include <cstdint>
		#include <memory>
		@@ -43,6 +44,7 @@

		using base::Bind;
		using bluetooth::Uuid;
		using namespace bluetooth;

		namespace {
		bool bta_jv_enabled = false;
		@@ -63,9 +65,9 @@ bool bta_jv_enabled = false;
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK* p_cback) {
		LOG_VERBOSE("");
		log::verbose("");
		if (!p_cback \|\| bta_jv_enabled) {
		LOG(ERROR) << __func__ << ": failure";
		log::error("failure");
		return BTA_JV_FAILURE;
		}

		@@ -85,7 +87,7 @@ tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK* p_cback) {

		/** Disable the Java I/F */
		void BTA_JvDisable(void) {
		VLOG(2) << __func__;
		log::verbose("");

		bta_jv_enabled = false;

		@@ -115,7 +117,7 @@ void BTA_JvDisable(void) {
		*
		******************************************************************************/
		void BTA_JvGetChannelId(int conn_type, uint32_t id, int32_t channel) {
		LOG_VERBOSE("conn_type:%d, id:%u, channel:%u", conn_type, id, channel);
		log::verbose("conn_type:{}, id:{}, channel:{}", conn_type, id, channel);

		if (conn_type != BTA_JV_CONN_TYPE_RFCOMM &&
		conn_type != BTA_JV_CONN_TYPE_L2CAP &&
		@@ -142,7 +144,7 @@ void BTA_JvGetChannelId(int conn_type, uint32_t id, int32_t channel) {
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvFreeChannel(uint16_t channel, int conn_type) {
		LOG_VERBOSE("channel:%u, conn_type:%d", channel, conn_type);
		log::verbose("channel:{}, conn_type:{}", channel, conn_type);

		do_in_main_thread(FROM_HERE, Bind(&bta_jv_free_scn, conn_type, channel));
		return BTA_JV_SUCCESS;
		@@ -164,7 +166,7 @@ tBTA_JV_STATUS BTA_JvFreeChannel(uint16_t channel, int conn_type) {
		tBTA_JV_STATUS BTA_JvStartDiscovery(const RawAddress& bd_addr,
		uint16_t num_uuid, const Uuid* p_uuid_list,
		uint32_t rfcomm_slot_id) {
		LOG_VERBOSE("bd_addr:%s, rfcomm_slot_id:%u, num_uuid:%u",
		log::verbose("bd_addr:{}, rfcomm_slot_id:{}, num_uuid:{}",
		ADDRESS_TO_LOGGABLE_CSTR(bd_addr), rfcomm_slot_id, num_uuid);

		Uuid* uuid_list_copy = new Uuid[num_uuid];
		@@ -189,7 +191,7 @@ tBTA_JV_STATUS BTA_JvStartDiscovery(const RawAddress& bd_addr,
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id) {
		LOG_VERBOSE("rfcomm_slot_id: %u", rfcomm_slot_id);
		log::verbose("rfcomm_slot_id: {}", rfcomm_slot_id);

		do_in_main_thread(FROM_HERE, Bind(&bta_jv_create_record, rfcomm_slot_id));
		return BTA_JV_SUCCESS;
		@@ -206,7 +208,7 @@ tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id) {
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvDeleteRecord(uint32_t handle) {
		LOG_VERBOSE("handle:%u", handle);
		log::verbose("handle:{}", handle);

		do_in_main_thread(FROM_HERE, Bind(&bta_jv_delete_record, handle));
		return BTA_JV_SUCCESS;
		@@ -231,9 +233,9 @@ void BTA_JvL2capConnect(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		const RawAddress& peer_bd_addr,
		tBTA_JV_L2CAP_CBACK* p_cback,
		uint32_t l2cap_socket_id) {
		LOG_VERBOSE(
		"conn_type:%d, role:%u, remote_psm:%u, peer_bd_addr:%s, "
		"l2cap_socket_id:%u",
		log::verbose(
		"conn_type:{}, role:{}, remote_psm:{}, peer_bd_addr:{}, "
		"l2cap_socket_id:{}",
		conn_type, role, remote_psm, ADDRESS_TO_LOGGABLE_CSTR(peer_bd_addr),
		l2cap_socket_id);
		CHECK(p_cback);
		@@ -255,7 +257,7 @@ void BTA_JvL2capConnect(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capClose(uint32_t handle) {
		LOG_VERBOSE("handle:%u", handle);
		log::verbose("handle:{}", handle);

		if (handle >= BTA_JV_MAX_L2C_CONN \|\| !bta_jv_cb.l2c_cb[handle].p_cback)
		return BTA_JV_FAILURE;
		@@ -285,7 +287,7 @@ void BTA_JvL2capStartServer(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		std::unique_ptr<tL2CAP_CFG_INFO> cfg,
		tBTA_JV_L2CAP_CBACK* p_cback,
		uint32_t l2cap_socket_id) {
		LOG_VERBOSE("conn_type:%d, role:%u, local_psm:%u, l2cap_socket_id:%u",
		log::verbose("conn_type:{}, role:{}, local_psm:{}, l2cap_socket_id:{}",
		conn_type, role, local_psm, l2cap_socket_id);
		CHECK(p_cback);

		@@ -308,7 +310,7 @@ void BTA_JvL2capStartServer(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capStopServer(uint16_t local_psm,
		uint32_t l2cap_socket_id) {
		LOG_VERBOSE("local_psm:%u, l2cap_socket_id:%u", local_psm, l2cap_socket_id);
		log::verbose("local_psm:{}, l2cap_socket_id:{}", local_psm, l2cap_socket_id);

		do_in_main_thread(
		FROM_HERE, Bind(&bta_jv_l2cap_stop_server, local_psm, l2cap_socket_id));
		@@ -329,7 +331,7 @@ tBTA_JV_STATUS BTA_JvL2capStopServer(uint16_t local_psm,
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capRead(uint32_t handle, uint32_t req_id,
		uint8_t* p_data, uint16_t len) {
		LOG_VERBOSE("handle:%u, req_id:%u, len:%u", handle, req_id, len);
		log::verbose("handle:{}, req_id:{}, len:{}", handle, req_id, len);

		if (handle >= BTA_JV_MAX_L2C_CONN \|\| !bta_jv_cb.l2c_cb[handle].p_cback)
		return BTA_JV_FAILURE;
		@@ -364,7 +366,7 @@ tBTA_JV_STATUS BTA_JvL2capRead(uint32_t handle, uint32_t req_id,
		tBTA_JV_STATUS BTA_JvL2capReady(uint32_t handle, uint32_t* p_data_size) {
		tBTA_JV_STATUS status = BTA_JV_FAILURE;

		LOG_VERBOSE("handle:%u", handle);
		log::verbose("handle:{}", handle);
		if (p_data_size && handle < BTA_JV_MAX_L2C_CONN &&
		bta_jv_cb.l2c_cb[handle].p_cback) {
		*p_data_size = 0;
		@@ -393,7 +395,7 @@ tBTA_JV_STATUS BTA_JvL2capReady(uint32_t handle, uint32_t* p_data_size) {
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id, BT_HDR* msg,
		uint32_t user_id) {
		LOG_VERBOSE("handle:%u, user_id:%u", handle, user_id);
		log::verbose("handle:{}, user_id:{}", handle, user_id);

		if (handle >= BTA_JV_MAX_L2C_CONN \|\| !bta_jv_cb.l2c_cb[handle].p_cback) {
		osi_free(msg);
		@@ -426,7 +428,7 @@ tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		const RawAddress& peer_bd_addr,
		tBTA_JV_RFCOMM_CBACK* p_cback,
		uint32_t rfcomm_slot_id) {
		LOG_VERBOSE("remote_scn:%u, peer_bd_addr:%s, rfcomm_slot_id:%u", remote_scn,
		log::verbose("remote_scn:{}, peer_bd_addr:{}, rfcomm_slot_id:{}", remote_scn,
		ADDRESS_TO_LOGGABLE_CSTR(peer_bd_addr), rfcomm_slot_id);

		if (!p_cback) return BTA_JV_FAILURE; /* Nothing to do */
		@@ -451,7 +453,7 @@ tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, uint32_t rfcomm_slot_id) {
		uint32_t hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
		uint32_t si = BTA_JV_RFC_HDL_TO_SIDX(handle);

		LOG_VERBOSE("handle:%u, rfcomm_slot_id:%u", handle, rfcomm_slot_id);
		log::verbose("handle:{}, rfcomm_slot_id:{}", handle, rfcomm_slot_id);

		if (hi >= BTA_JV_MAX_RFC_CONN \|\| !bta_jv_cb.rfc_cb[hi].p_cback \|\|
		si >= BTA_JV_MAX_RFC_SR_SESSION \|\| !bta_jv_cb.rfc_cb[hi].rfc_hdl[si])
		@@ -481,14 +483,13 @@ tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		uint8_t local_scn, uint8_t max_session,
		tBTA_JV_RFCOMM_CBACK* p_cback,
		uint32_t rfcomm_slot_id) {
		LOG_VERBOSE("local_scn:%u, rfcomm_slot_id:%u", local_scn, rfcomm_slot_id);
		log::verbose("local_scn:{}, rfcomm_slot_id:{}", local_scn, rfcomm_slot_id);

		if (p_cback == NULL) return BTA_JV_FAILURE; /* Nothing to do */

		if (max_session == 0) max_session = 1;
		if (max_session > BTA_JV_MAX_RFC_SR_SESSION) {
		LOG(INFO) << __func__ << "max_session is too big. use max "
		<< BTA_JV_MAX_RFC_SR_SESSION;
		log::info("max_session is too big. use max {}", BTA_JV_MAX_RFC_SR_SESSION);
		max_session = BTA_JV_MAX_RFC_SR_SESSION;
		}

		@@ -511,7 +512,7 @@ tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle,
		uint32_t rfcomm_slot_id) {
		LOG_VERBOSE("handle:%u, rfcomm_slot_id:%u", handle, rfcomm_slot_id);
		log::verbose("handle:{}, rfcomm_slot_id:{}", handle, rfcomm_slot_id);

		do_in_main_thread(FROM_HERE,
		Bind(&bta_jv_rfcomm_stop_server, handle, rfcomm_slot_id));
		@@ -552,13 +553,13 @@ tBTA_JV_STATUS BTA_JvRfcommWrite(uint32_t handle, uint32_t req_id) {
		uint32_t hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
		uint32_t si = BTA_JV_RFC_HDL_TO_SIDX(handle);

		LOG_VERBOSE("handle:%u, req_id:%u, hi:%u, si:%u", handle, req_id, hi, si);
		log::verbose("handle:{}, req_id:{}, hi:{}, si:{}", handle, req_id, hi, si);
		if (hi >= BTA_JV_MAX_RFC_CONN \|\| !bta_jv_cb.rfc_cb[hi].p_cback \|\|
		si >= BTA_JV_MAX_RFC_SR_SESSION \|\| !bta_jv_cb.rfc_cb[hi].rfc_hdl[si]) {
		return BTA_JV_FAILURE;
		}

		LOG_VERBOSE("write ok");
		log::verbose("write ok");

		tBTA_JV_RFC_CB* p_cb = &bta_jv_cb.rfc_cb[hi];
		do_in_main_thread(FROM_HERE, Bind(&bta_jv_rfcomm_write, handle, req_id, p_cb,
		@@ -591,7 +592,7 @@ tBTA_JV_STATUS BTA_JvRfcommWrite(uint32_t handle, uint32_t req_id) {
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvSetPmProfile(uint32_t handle, tBTA_JV_PM_ID app_id,
		tBTA_JV_CONN_STATE init_st) {
		LOG_VERBOSE("handle:%u, app_id:%u, init_st:%u", handle, app_id, handle);
		log::verbose("handle:{}, app_id:{}, init_st:{}", handle, app_id, handle);

		do_in_main_thread(FROM_HERE,
		Bind(&bta_jv_set_pm_profile, handle, app_id, init_st));