Add A2DP src and sink co-exist feature profile/avrcp layer (4/5) (112fe86b) · Commits · e / os / android_packages_modules_Bluetooth

system/profile/avrcp/Android.bp

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -30,6 +30,9 @@ cc_library_static {
	"libbluetooth-types",		"libbluetooth-types",
	"libosi",		"libosi",
	],		],
			whole_static_libs: [
			"libcom.android.sysprop.bluetooth",
			],
	shared_libs: [		shared_libs: [
	"liblog",		"liblog",
	],		],

system/profile/avrcp/connection_handler.cc

+72 −15

Original line number	Original line	Diff line number	Diff line
	@@ -20,6 +20,7 @@
	#include <base/logging.h>		#include <base/logging.h>

	#include <map>		#include <map>
			#include <mutex>

	#include "avrc_defs.h"		#include "avrc_defs.h"
	#include "avrcp_message_converter.h"		#include "avrcp_message_converter.h"
	@@ -33,11 +34,19 @@
	#include "stack/include/bt_hdr.h"		#include "stack/include/bt_hdr.h"
	#include "types/raw_address.h"		#include "types/raw_address.h"

			extern bool btif_av_peer_is_connected_sink(const RawAddress& peer_address);
			extern bool btif_av_peer_is_connected_source(const RawAddress& peer_address);
			extern bool btif_av_both_enable(void);
			extern bool btif_av_src_sink_coexist_enabled(void);
			extern bool btif_av_peer_is_source(const RawAddress& peer_address);

	namespace bluetooth {		namespace bluetooth {
	namespace avrcp {		namespace avrcp {

	ConnectionHandler* ConnectionHandler::instance_ = nullptr;		ConnectionHandler* ConnectionHandler::instance_ = nullptr;

			std::mutex device_map_lock;

	ConnectionHandler* ConnectionHandler::Get() {		ConnectionHandler* ConnectionHandler::Get() {
	CHECK(instance_);		CHECK(instance_);

	@@ -86,6 +95,7 @@ bool ConnectionHandler::CleanUp() {
	CHECK(instance_ != nullptr);		CHECK(instance_ != nullptr);

	// TODO (apanicke): Cleanup the SDP Entries here		// TODO (apanicke): Cleanup the SDP Entries here
			std::lock_guard<std::mutex> lock(device_map_lock);
	for (auto entry = instance_->device_map_.begin();		for (auto entry = instance_->device_map_.begin();
	entry != instance_->device_map_.end();) {		entry != instance_->device_map_.end();) {
	auto curr = entry;		auto curr = entry;
	@@ -165,6 +175,7 @@ void ConnectionHandler::SetBipClientStatus(const RawAddress& bdaddr,
	std::vector<std::shared_ptr<Device>> ConnectionHandler::GetListOfDevices()		std::vector<std::shared_ptr<Device>> ConnectionHandler::GetListOfDevices()
	const {		const {
	std::vector<std::shared_ptr<Device>> list;		std::vector<std::shared_ptr<Device>> list;
			std::lock_guard<std::mutex> lock(device_map_lock);
	for (const auto& device : device_map_) {		for (const auto& device : device_map_) {
	list.push_back(device.second);		list.push_back(device.second);
	}		}
	@@ -214,8 +225,8 @@ bool ConnectionHandler::AvrcpConnect(bool initiator, const RawAddress& bdaddr) {
	: AVRC_CONN_ACP; // 0 if initiator, 1 if acceptor		: AVRC_CONN_ACP; // 0 if initiator, 1 if acceptor
	// TODO (apanicke): We shouldn't need RCCT to do absolute volume. The current		// TODO (apanicke): We shouldn't need RCCT to do absolute volume. The current
	// AVRC_API requires it though.		// AVRC_API requires it though.
	open_cb.control = BTA_AV_FEAT_RCTG \| BTA_AV_FEAT_RCCT \| BTA_AV_FEAT_METADATA		open_cb.control = BTA_AV_FEAT_RCTG \| BTA_AV_FEAT_RCCT \| BTA_AV_FEAT_METADATA \|
	\| AVRC_CT_PASSIVE;		AVRC_CT_PASSIVE;

	uint8_t handle = 0;		uint8_t handle = 0;
	uint16_t status = avrc_->Open(&handle, &open_cb, bdaddr);		uint16_t status = avrc_->Open(&handle, &open_cb, bdaddr);
	@@ -267,11 +278,15 @@ void ConnectionHandler::InitiatorControlCb(uint8_t handle, uint8_t event,
	// interfaces it needs.		// interfaces it needs.
	connection_cb_.Run(newDevice);		connection_cb_.Run(newDevice);

			if (!btif_av_src_sink_coexist_enabled() \|\|
			(btif_av_src_sink_coexist_enabled() &&
			btif_av_peer_is_connected_sink(newDevice->GetAddress()))) {
	if (feature_iter->second & BTA_AV_FEAT_ADV_CTRL) {		if (feature_iter->second & BTA_AV_FEAT_ADV_CTRL) {
	newDevice->RegisterVolumeChanged();		newDevice->RegisterVolumeChanged();
	} else if (instance_->vol_ != nullptr) {		} else if (instance_->vol_ != nullptr) {
	instance_->vol_->DeviceConnected(newDevice->GetAddress());		instance_->vol_->DeviceConnected(newDevice->GetAddress());
	}		}
			}

	} break;		} break;

	@@ -283,6 +298,7 @@ void ConnectionHandler::InitiatorControlCb(uint8_t handle, uint8_t event,
	<< "Connection Close received from device that doesn't exist";		<< "Connection Close received from device that doesn't exist";
	return;		return;
	}		}
			std::lock_guard<std::mutex> lock(device_map_lock);
	avrc_->Close(handle);		avrc_->Close(handle);
	feature_map_.erase(device_map_[handle]->GetAddress());		feature_map_.erase(device_map_[handle]->GetAddress());
	device_map_[handle]->DeviceDisconnected();		device_map_[handle]->DeviceDisconnected();
	@@ -324,7 +340,19 @@ void ConnectionHandler::AcceptorControlCb(uint8_t handle, uint8_t event,
	switch (event) {		switch (event) {
	case AVRC_OPEN_IND_EVT: {		case AVRC_OPEN_IND_EVT: {
	LOG(INFO) << __PRETTY_FUNCTION__ << ": Connection Opened Event";		LOG(INFO) << __PRETTY_FUNCTION__ << ": Connection Opened Event";
			if (btif_av_src_sink_coexist_enabled() && peer_addr != NULL &&
			btif_av_peer_is_connected_source(*peer_addr)) {
			LOG(WARNING) << "peer is src, close new avrcp cback";
			if (device_map_.find(handle) != device_map_.end()) {
			std::lock_guard<std::mutex> lock(device_map_lock);
			feature_map_.erase(device_map_[handle]->GetAddress());
			device_map_[handle]->DeviceDisconnected();
			device_map_.erase(handle);
			}
			avrc_->Close(handle);
			AvrcpConnect(false, RawAddress::kAny);
			return;
			}
	auto&& callback = base::Bind(&ConnectionHandler::SendMessage,		auto&& callback = base::Bind(&ConnectionHandler::SendMessage,
	weak_ptr_factory_.GetWeakPtr(), handle);		weak_ptr_factory_.GetWeakPtr(), handle);
	auto&& ctrl_mtu = avrc_->GetPeerMtu(handle) - AVCT_HDR_LEN;		auto&& ctrl_mtu = avrc_->GetPeerMtu(handle) - AVCT_HDR_LEN;
	@@ -353,11 +381,15 @@ void ConnectionHandler::AcceptorControlCb(uint8_t handle, uint8_t event,

	// TODO (apanicke): Report to the VolumeInterface that a new Device is		// TODO (apanicke): Report to the VolumeInterface that a new Device is
	// connected that doesn't support absolute volume.		// connected that doesn't support absolute volume.
			if (!btif_av_src_sink_coexist_enabled() \|\|
			(btif_av_src_sink_coexist_enabled() &&
			btif_av_peer_is_connected_sink(device->GetAddress()))) {
	if (features & BTA_AV_FEAT_ADV_CTRL) {		if (features & BTA_AV_FEAT_ADV_CTRL) {
	device->RegisterVolumeChanged();		device->RegisterVolumeChanged();
	} else if (instance_->vol_ != nullptr) {		} else if (instance_->vol_ != nullptr) {
	instance_->vol_->DeviceConnected(device->GetAddress());		instance_->vol_->DeviceConnected(device->GetAddress());
	}		}
			}
	};		};

	SdpLookup(*peer_addr, base::Bind(sdp_lambda, this, handle), false);		SdpLookup(*peer_addr, base::Bind(sdp_lambda, this, handle), false);
	@@ -374,10 +406,13 @@ void ConnectionHandler::AcceptorControlCb(uint8_t handle, uint8_t event,
	<< "Connection Close received from device that doesn't exist";		<< "Connection Close received from device that doesn't exist";
	return;		return;
	}		}
	avrc_->Close(handle);		{
			std::lock_guard<std::mutex> lock(device_map_lock);
	feature_map_.erase(device_map_[handle]->GetAddress());		feature_map_.erase(device_map_[handle]->GetAddress());
	device_map_[handle]->DeviceDisconnected();		device_map_[handle]->DeviceDisconnected();
	device_map_.erase(handle);		device_map_.erase(handle);
			}
			avrc_->Close(handle);
	} break;		} break;

	case AVRC_BROWSE_OPEN_IND_EVT: {		case AVRC_BROWSE_OPEN_IND_EVT: {
	@@ -414,6 +449,12 @@ void ConnectionHandler::MessageCb(uint8_t handle, uint8_t label, uint8_t opcode,
	auto pkt = AvrcpMessageConverter::Parse(p_msg);		auto pkt = AvrcpMessageConverter::Parse(p_msg);

	if (opcode == AVRC_OP_BROWSE) {		if (opcode == AVRC_OP_BROWSE) {
			if (btif_av_src_sink_coexist_enabled() && btif_av_both_enable()) {
			if (p_msg->browse.hdr.ctype == AVCT_RSP) {
			VLOG(2) << "ignore response handle " << (unsigned int)handle;
			return;
			}
			}
	VLOG(4) << "Browse Message received on handle " << (unsigned int)handle;		VLOG(4) << "Browse Message received on handle " << (unsigned int)handle;
	device_map_[handle]->BrowseMessageReceived(label, BrowsePacket::Parse(pkt));		device_map_[handle]->BrowseMessageReceived(label, BrowsePacket::Parse(pkt));
	return;		return;
	@@ -566,7 +607,8 @@ void ConnectionHandler::SendMessage(
	// the packet so none of these layer specific fields will be used.		// the packet so none of these layer specific fields will be used.
	pkt->event = 0xFFFF;		pkt->event = 0xFFFF;
	/* Handle for AVRCP fragment */		/* Handle for AVRCP fragment */
	uint16_t op_code = (uint16_t)(::bluetooth::Packet::Specialize<Packet>(packet)->GetOpcode());		uint16_t op_code =
			(uint16_t)(::bluetooth::Packet::Specialize<Packet>(packet)->GetOpcode());
	if (!browse && (op_code == (uint16_t)(Opcode::VENDOR))) {		if (!browse && (op_code == (uint16_t)(Opcode::VENDOR))) {
	pkt->event = op_code;		pkt->event = op_code;
	}		}
	@@ -587,5 +629,20 @@ void ConnectionHandler::SendMessage(
	avrc_->MsgReq(handle, label, ctype, pkt);		avrc_->MsgReq(handle, label, ctype, pkt);
	}		}

			void ConnectionHandler::RegisterVolChanged(const RawAddress& bdaddr) {
			LOG(INFO) << "Attempting to RegisterVolChanged device " << bdaddr;
			for (auto it = device_map_.begin(); it != device_map_.end(); it++) {
			if (bdaddr == it->second->GetAddress()) {
			const auto& feature_iter = feature_map_.find(bdaddr);
			if (feature_iter->second & BTA_AV_FEAT_ADV_CTRL) {
			it->second->RegisterVolumeChanged();
			} else if (instance_->vol_ != nullptr) {
			instance_->vol_->DeviceConnected(bdaddr);
			}
			break;
			}
			}
			}

	} // namespace avrcp		} // namespace avrcp
	} // namespace bluetooth		} // namespace bluetooth

system/profile/avrcp/connection_handler.h

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -127,6 +127,8 @@ class ConnectionHandler {
	*/		*/
	static void InitForTesting(ConnectionHandler* handler);		static void InitForTesting(ConnectionHandler* handler);

			virtual void RegisterVolChanged(const RawAddress& bdaddr);

	private:		private:
	AvrcpInterface* avrc_;		AvrcpInterface* avrc_;
	SdpInterface* sdp_;		SdpInterface* sdp_;

system/profile/avrcp/device.cc

+57 −34

Original line number	Original line	Diff line number	Diff line
	@@ -15,6 +15,8 @@
	*/		*/
	#include "device.h"		#include "device.h"

			#include <base/logging.h>

	#include "abstract_message_loop.h"		#include "abstract_message_loop.h"
	#include "avrcp_common.h"		#include "avrcp_common.h"
	#include "connection_handler.h"		#include "connection_handler.h"
	@@ -31,6 +33,10 @@
	#include "stack_config.h"		#include "stack_config.h"
	#include "types/raw_address.h"		#include "types/raw_address.h"

			extern bool btif_av_peer_is_connected_sink(const RawAddress& peer_address);
			extern bool btif_av_both_enable(void);
			extern bool btif_av_src_sink_coexist_enabled(void);

	namespace bluetooth {		namespace bluetooth {
	namespace avrcp {		namespace avrcp {

	@@ -68,9 +74,7 @@ void Device::RegisterInterfaces(
	player_settings_interface_ = player_settings_interface;		player_settings_interface_ = player_settings_interface;
	}		}

	base::WeakPtr<Device> Device::Get() {		base::WeakPtr<Device> Device::Get() { return weak_ptr_factory_.GetWeakPtr(); }
	return weak_ptr_factory_.GetWeakPtr();
	}

	void Device::SetBrowseMtu(uint16_t browse_mtu) {		void Device::SetBrowseMtu(uint16_t browse_mtu) {
	DEVICE_LOG(INFO) << __PRETTY_FUNCTION__ << ": browse_mtu = " << browse_mtu;		DEVICE_LOG(INFO) << __PRETTY_FUNCTION__ << ": browse_mtu = " << browse_mtu;
	@@ -82,9 +86,7 @@ void Device::SetBipClientStatus(bool connected) {
	has_bip_client_ = connected;		has_bip_client_ = connected;
	}		}

	bool Device::HasBipClient() const {		bool Device::HasBipClient() const { return has_bip_client_; }
	return has_bip_client_;
	}

	void filter_cover_art(SongInfo& s) {		void filter_cover_art(SongInfo& s) {
	for (auto it = s.attributes.begin(); it != s.attributes.end(); it++) {		for (auto it = s.attributes.begin(); it != s.attributes.end(); it++) {
	@@ -110,7 +112,8 @@ void Device::VendorPacketHandler(uint8_t label,

	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = RejectBuilder::MakeBuilder(static_cast<CommandPdu>(0), Status::INVALID_COMMAND);		auto response = RejectBuilder::MakeBuilder(static_cast<CommandPdu>(0),
			Status::INVALID_COMMAND);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	return;		return;
	}		}
	@@ -127,10 +130,12 @@ void Device::VendorPacketHandler(uint8_t label,
	auto register_notification =		auto register_notification =
	Packet::Specialize<RegisterNotificationResponse>(pkt);		Packet::Specialize<RegisterNotificationResponse>(pkt);

	if (!register_notification->IsValid()) {		if ((!btif_av_src_sink_coexist_enabled() \|\|
			(btif_av_src_sink_coexist_enabled() &&
			register_notification->GetEvent() == Event::VOLUME_CHANGED)) &&
			!register_notification->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response =		auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(),
	RejectBuilder::MakeBuilder(pkt->GetCommandPdu(),
	Status::INVALID_PARAMETER);		Status::INVALID_PARAMETER);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	active_labels_.erase(label);		active_labels_.erase(label);
	@@ -173,15 +178,18 @@ void Device::VendorPacketHandler(uint8_t label,
	} break;		} break;

	case CommandPdu::GET_ELEMENT_ATTRIBUTES: {		case CommandPdu::GET_ELEMENT_ATTRIBUTES: {
	auto get_element_attributes_request_pkt = Packet::Specialize<GetElementAttributesRequest>(pkt);		auto get_element_attributes_request_pkt =
			Packet::Specialize<GetElementAttributesRequest>(pkt);

	if (!get_element_attributes_request_pkt->IsValid()) {		if (!get_element_attributes_request_pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(), Status::INVALID_PARAMETER);		auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(),
			Status::INVALID_PARAMETER);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	return;		return;
	}		}
	media_interface_->GetSongInfo(base::Bind(&Device::GetElementAttributesResponse, weak_ptr_factory_.GetWeakPtr(),		media_interface_->GetSongInfo(base::Bind(
			&Device::GetElementAttributesResponse, weak_ptr_factory_.GetWeakPtr(),
	label, get_element_attributes_request_pkt));		label, get_element_attributes_request_pkt));
	} break;		} break;

	@@ -200,16 +208,19 @@ void Device::VendorPacketHandler(uint8_t label,
	// this currently since the current implementation only has one		// this currently since the current implementation only has one
	// player and the player will never change, but we need it for a		// player and the player will never change, but we need it for a
	// more complete implementation.		// more complete implementation.
	auto set_addressed_player_request = Packet::Specialize<SetAddressedPlayerRequest>(pkt);		auto set_addressed_player_request =
			Packet::Specialize<SetAddressedPlayerRequest>(pkt);

	if (!set_addressed_player_request->IsValid()) {		if (!set_addressed_player_request->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(), Status::INVALID_PARAMETER);		auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(),
			Status::INVALID_PARAMETER);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	return;		return;
	}		}

	media_interface_->GetMediaPlayerList(base::Bind(&Device::HandleSetAddressedPlayer, weak_ptr_factory_.GetWeakPtr(),		media_interface_->GetMediaPlayerList(base::Bind(
			&Device::HandleSetAddressedPlayer, weak_ptr_factory_.GetWeakPtr(),
	label, set_addressed_player_request));		label, set_addressed_player_request));
	} break;		} break;

	@@ -393,7 +404,8 @@ void Device::HandleGetCapabilities(

	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(), Status::INVALID_PARAMETER);		auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(),
			Status::INVALID_PARAMETER);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	return;		return;
	}		}
	@@ -857,7 +869,8 @@ void Device::GetElementAttributesResponse(
	void Device::MessageReceived(uint8_t label, std::shared_ptr<Packet> pkt) {		void Device::MessageReceived(uint8_t label, std::shared_ptr<Packet> pkt) {
	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = RejectBuilder::MakeBuilder(static_cast<CommandPdu>(0), Status::INVALID_COMMAND);		auto response = RejectBuilder::MakeBuilder(static_cast<CommandPdu>(0),
			Status::INVALID_COMMAND);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	return;		return;
	}		}
	@@ -873,15 +886,17 @@ void Device::MessageReceived(uint8_t label, std::shared_ptr<Packet> pkt) {
	} break;		} break;
	case Opcode::PASS_THROUGH: {		case Opcode::PASS_THROUGH: {
	/** Newavrcp not passthrough response pkt. @{ */		/** Newavrcp not passthrough response pkt. @{ */
	if (pkt->GetCType() == CType::ACCEPTED \|\| pkt->GetCType() == CType::REJECTED		if (pkt->GetCType() == CType::ACCEPTED \|\|
	\|\| pkt->GetCType() == CType::NOT_IMPLEMENTED)		pkt->GetCType() == CType::REJECTED \|\|
			pkt->GetCType() == CType::NOT_IMPLEMENTED)
	break;		break;
	/** @} */		/** @} */
	auto pass_through_packet = Packet::Specialize<PassThroughPacket>(pkt);		auto pass_through_packet = Packet::Specialize<PassThroughPacket>(pkt);

	if (!pass_through_packet->IsValid()) {		if (!pass_through_packet->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = RejectBuilder::MakeBuilder(static_cast<CommandPdu>(0), Status::INVALID_COMMAND);		auto response = RejectBuilder::MakeBuilder(static_cast<CommandPdu>(0),
			Status::INVALID_COMMAND);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	return;		return;
	}		}
	@@ -938,7 +953,8 @@ void Device::HandlePlayItem(uint8_t label,

	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(), Status::INVALID_PARAMETER);		auto response = RejectBuilder::MakeBuilder(pkt->GetCommandPdu(),
			Status::INVALID_PARAMETER);
	send_message(label, false, std::move(response));		send_message(label, false, std::move(response));
	return;		return;
	}		}
	@@ -1104,7 +1120,8 @@ void Device::BrowseMessageReceived(uint8_t label,
	break;		break;
	default:		default:
	DEVICE_LOG(WARNING) << __func__ << ": " << pkt->GetPdu();		DEVICE_LOG(WARNING) << __func__ << ": " << pkt->GetPdu();
	auto response = GeneralRejectBuilder::MakeBuilder(Status::INVALID_COMMAND);		auto response =
			GeneralRejectBuilder::MakeBuilder(Status::INVALID_COMMAND);
	send_message(label, true, std::move(response));		send_message(label, true, std::move(response));

	break;		break;
	@@ -1115,9 +1132,10 @@ void Device::HandleGetFolderItems(uint8_t label,
	std::shared_ptr<GetFolderItemsRequest> pkt) {		std::shared_ptr<GetFolderItemsRequest> pkt) {
	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	// The specific get folder items builder is unimportant on failure.		// The specific get folder items builder is unimportant on failure.
	DEVICE_LOG(WARNING) << __func__ << ": Get folder items request packet is not valid";		DEVICE_LOG(WARNING) << __func__
	auto response =		<< ": Get folder items request packet is not valid";
	GetFolderItemsResponseBuilder::MakePlayerListBuilder(Status::INVALID_PARAMETER, 0x0000, browse_mtu_);		auto response = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
			Status::INVALID_PARAMETER, 0x0000, browse_mtu_);
	send_message(label, true, std::move(response));		send_message(label, true, std::move(response));
	return;		return;
	}		}
	@@ -1143,7 +1161,8 @@ void Device::HandleGetFolderItems(uint8_t label,
	break;		break;
	default:		default:
	DEVICE_LOG(ERROR) << __func__ << ": " << pkt->GetScope();		DEVICE_LOG(ERROR) << __func__ << ": " << pkt->GetScope();
	auto response = GetFolderItemsResponseBuilder::MakePlayerListBuilder(Status::INVALID_PARAMETER, 0, browse_mtu_);		auto response = GetFolderItemsResponseBuilder::MakePlayerListBuilder(
			Status::INVALID_PARAMETER, 0, browse_mtu_);
	send_message(label, true, std::move(response));		send_message(label, true, std::move(response));
	break;		break;
	}		}
	@@ -1153,7 +1172,8 @@ void Device::HandleGetTotalNumberOfItems(
	uint8_t label, std::shared_ptr<GetTotalNumberOfItemsRequest> pkt) {		uint8_t label, std::shared_ptr<GetTotalNumberOfItemsRequest> pkt) {
	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = GetTotalNumberOfItemsResponseBuilder::MakeBuilder(Status::INVALID_PARAMETER, 0x0000, 0);		auto response = GetTotalNumberOfItemsResponseBuilder::MakeBuilder(
			Status::INVALID_PARAMETER, 0x0000, 0);
	send_message(label, true, std::move(response));		send_message(label, true, std::move(response));
	return;		return;
	}		}
	@@ -1215,7 +1235,8 @@ void Device::HandleChangePath(uint8_t label,
	std::shared_ptr<ChangePathRequest> pkt) {		std::shared_ptr<ChangePathRequest> pkt) {
	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = ChangePathResponseBuilder::MakeBuilder(Status::INVALID_PARAMETER, 0);		auto response =
			ChangePathResponseBuilder::MakeBuilder(Status::INVALID_PARAMETER, 0);
	send_message(label, true, std::move(response));		send_message(label, true, std::move(response));
	return;		return;
	}		}
	@@ -1272,7 +1293,8 @@ void Device::HandleGetItemAttributes(
	uint8_t label, std::shared_ptr<GetItemAttributesRequest> pkt) {		uint8_t label, std::shared_ptr<GetItemAttributesRequest> pkt) {
	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto builder = GetItemAttributesResponseBuilder::MakeBuilder(Status::INVALID_PARAMETER, browse_mtu_);		auto builder = GetItemAttributesResponseBuilder::MakeBuilder(
			Status::INVALID_PARAMETER, browse_mtu_);
	send_message(label, true, std::move(builder));		send_message(label, true, std::move(builder));
	return;		return;
	}		}
	@@ -1586,7 +1608,8 @@ void Device::HandleSetBrowsedPlayer(
	uint8_t label, std::shared_ptr<SetBrowsedPlayerRequest> pkt) {		uint8_t label, std::shared_ptr<SetBrowsedPlayerRequest> pkt) {
	if (!pkt->IsValid()) {		if (!pkt->IsValid()) {
	DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";		DEVICE_LOG(WARNING) << __func__ << ": Request packet is not valid";
	auto response = SetBrowsedPlayerResponseBuilder::MakeBuilder(Status::INVALID_PARAMETER, 0x0000, 0, 0, "");		auto response = SetBrowsedPlayerResponseBuilder::MakeBuilder(
			Status::INVALID_PARAMETER, 0x0000, 0, 0, "");
	send_message(label, true, std::move(response));		send_message(label, true, std::move(response));
	return;		return;
	}		}

system/profile/avrcp/tests/avrcp_connection_handler_test.cc

+8 −0

Original line number	Original line	Diff line number	Diff line
	@@ -34,6 +34,14 @@ using ::testing::SaveArgPointee;
	using ::testing::SetArgPointee;		using ::testing::SetArgPointee;
	using ::testing::StrictMock;		using ::testing::StrictMock;

			bool btif_av_peer_is_connected_sink(const RawAddress& peer_address) {
			return true;
			}
			bool btif_av_peer_is_connected_source(const RawAddress& peer_address) {
			return false;
			}
			bool btif_av_both_enable(void) { return false; }

	namespace bluetooth {		namespace bluetooth {
	namespace avrcp {		namespace avrcp {