service/avrcp_target.cc - platform/system/bt - Git at Google

 //
 //  Copyright (C) 2017 Google, Inc.
 //
 //  Licensed under the Apache License, Version 2.0 (the "License");
 //  you may not use this file except in compliance with the License.
 //  You may obtain a copy of the License at:
 //
 //  http://www.apache.org/licenses/LICENSE-2.0
 //
 //  Unless required by applicable law or agreed to in writing, software
 //  distributed under the License is distributed on an "AS IS" BASIS,
 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 //

 #include "service/avrcp_target.h"

 #include <algorithm>
 #include <cerrno>
 #include <climits>
 #include <string>

 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "service/logging_helpers.h"

 #include "array_utils.h"
 #include "stack/include/avrc_defs.h"

 #define PARSE_ADDR(str)                                        \
   ({                                                           \
     RawAddress tmp;                                            \
     if (!RawAddress::FromString((str), tmp)) {                 \
       LOG(ERROR) << "Invalid device address given: " << (str); \
       return false;                                            \
     }                                                          \
     tmp;                                                       \
   })

 #define TRY_RET(expr, err_msg) \
   do {                         \
     if (!(expr)) {             \
       LOG(ERROR) << err_msg;   \
       return false;            \
     }                          \
     return true;               \
   } while (0)

 #define TRY_RET_FUNC(expr) TRY_RET(expr, __func__ << " failed")

 using LockGuard = std::lock_guard<std::mutex>;

 namespace bluetooth {

 namespace {

 std::vector<btrc_player_setting_text_t> StringValueToPlayerSettingsText(
     const std::vector<AvrcpStringValue>& attrs) {
   std::vector<btrc_player_setting_text_t> btrc_attrs(attrs.size());
   for (size_t i = 0; i < attrs.size(); ++i) {
     btrc_attrs[i].id = attrs[i].id();
     std::string str(attrs[i].value());
     size_t to_copy = std::min(sizeof(btrc_attrs[i].text) - 1, str.size());
     if (to_copy < str.size()) {
       LOG(WARNING) << "Value truncated";
     }

     memcpy(btrc_attrs[i].text, str.data(), to_copy);
     btrc_attrs[i].text[to_copy] = '\0';
   }

   return btrc_attrs;
 }

 std::vector<btrc_element_attr_val_t> StringValueToElementAttrVal(
     const std::vector<AvrcpStringValue>& attrs) {
   std::vector<btrc_element_attr_val_t> btrc_attrs(attrs.size());
   for (size_t i = 0; i < attrs.size(); ++i) {
     btrc_attrs[i].attr_id = attrs[i].id();
     std::string str(attrs[i].value());
     size_t to_copy = std::min(sizeof(btrc_attrs[i].text) - 1, str.size());
     if (to_copy < str.size()) {
       LOG(WARNING) << "Value truncated";
     }

     memcpy(btrc_attrs[i].text, str.data(), to_copy);
     btrc_attrs[i].text[to_copy] = '\0';
   }

   return btrc_attrs;
 }

 }  // namespace

 // static
 const int AvrcpTarget::kSingletonInstanceId = 0;

 AvrcpTarget::AvrcpTarget(const Uuid& uuid) : app_identifier_(uuid) {
   hal::BluetoothAvrcpInterface::Get()->AddTargetObserver(this);
 }

 AvrcpTarget::~AvrcpTarget() {
   hal::BluetoothAvrcpInterface::Get()->RemoveTargetObserver(this);
 }

 const Uuid& AvrcpTarget::GetAppIdentifier() const { return app_identifier_; }

 int AvrcpTarget::GetInstanceId() const { return kSingletonInstanceId; }

 void AvrcpTarget::SetDelegate(Delegate* delegate) {
   LockGuard lock(delegate_mutex_);
   delegate_ = delegate;
 }

 bool AvrcpTarget::Enable() {
   LockGuard lock(mutex_);
   return hal::BluetoothAvrcpInterface::Get()->AvrcpTargetEnable();
 }

 void AvrcpTarget::Disable() {
   LockGuard lock(mutex_);
   hal::BluetoothAvrcpInterface::Get()->AvrcpTargetDisable();
 }

 bool AvrcpTarget::GetPlayStatusResponse(const std::string& str_addr,
                                         int32_t play_status, uint32_t song_len,
                                         uint32_t song_pos) {
   RawAddress addr = PARSE_ADDR(str_addr);
   LockGuard lock(mutex_);
   TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
                    ->GetTargetHALInterface()
                    ->get_play_status_rsp(
                        addr, static_cast<btrc_play_status_t>(play_status),
                        song_len, song_pos) == BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::ListPlayerAppAttrResponse(const std::string& str_addr,
                                             const std::vector<int32_t>& attrs) {
   RawAddress addr = PARSE_ADDR(str_addr);

   std::vector<btrc_player_attr_t> btrc_attrs;
   btrc_attrs.reserve(attrs.size());
   for (auto attr : attrs) {
     btrc_attrs.push_back(static_cast<btrc_player_attr_t>(attr));
   }

   LockGuard lock(mutex_);
   TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
                    ->GetTargetHALInterface()
                    ->list_player_app_attr_rsp(addr, btrc_attrs.size(),
                                               btrc_attrs.data()) ==
                BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::GetPlayerAppValueResponse(
     const std::string& str_addr, const std::vector<AvrcpIntValue>& values) {
   RawAddress addr = PARSE_ADDR(str_addr);
   btrc_player_settings_t btrc_values;
   if (values.size() >= ARRAY_SIZE(btrc_values.attr_ids)) {
     LOG(ERROR) << "Too many attribute values";
     return false;
   }

   btrc_values.num_attr = values.size();
   for (size_t i = 0; i < values.size(); ++i) {
     btrc_values.attr_ids[i] = values[i].id();
     btrc_values.attr_values[i] = values[i].value();
   }

   LockGuard lock(mutex_);
   TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
                    ->GetTargetHALInterface()
                    ->get_player_app_value_rsp(addr, &btrc_values) ==
                BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::GetPlayerAppAttrTextResponse(
     const std::string& str_addr, const std::vector<AvrcpStringValue>& attrs) {
   RawAddress addr = PARSE_ADDR(str_addr);
   auto btrc_attrs = StringValueToPlayerSettingsText(attrs);
   LockGuard lock(mutex_);
   TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
                    ->GetTargetHALInterface()
                    ->get_player_app_attr_text_rsp(addr, btrc_attrs.size(),
                                                   btrc_attrs.data()) ==
                BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::GetPlayerAppValueTextResponse(
     const std::string& str_addr, const std::vector<AvrcpStringValue>& values) {
   RawAddress addr = PARSE_ADDR(str_addr);
   auto btrc_values = StringValueToPlayerSettingsText(values);
   LockGuard lock(mutex_);
   TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
                    ->GetTargetHALInterface()
                    ->get_player_app_value_text_rsp(addr, btrc_values.size(),
                                                    btrc_values.data()) ==
                BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::GetElementAttrResponse(
     const std::string& str_addr, const std::vector<AvrcpStringValue>& attrs) {
   RawAddress addr = PARSE_ADDR(str_addr);
   auto btrc_attrs = StringValueToElementAttrVal(attrs);
   LockGuard lock(mutex_);
   TRY_RET_FUNC(
       hal::BluetoothAvrcpInterface::Get()
           ->GetTargetHALInterface()
           ->get_element_attr_rsp(addr, btrc_attrs.size(), btrc_attrs.data()) ==
       BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::SetPlayerAppValueResponse(const std::string& str_addr,
                                             int32_t rsp_status) {
   RawAddress addr = PARSE_ADDR(str_addr);
   LockGuard lock(mutex_);
   TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
                    ->GetTargetHALInterface()
                    ->set_player_app_value_rsp(
                        addr, static_cast<btrc_status_t>(rsp_status)) ==
                BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::RegisterNotificationResponse(
     int32_t event_id, int32_t type,
     const AvrcpRegisterNotificationResponse& param) {
   auto param_copy = param.data();
   LockGuard lock(mutex_);
   TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
                    ->GetTargetHALInterface()
                    ->register_notification_rsp(
                        static_cast<btrc_event_id_t>(event_id),
                        static_cast<btrc_notification_type_t>(type),
                        &param_copy) == BT_STATUS_SUCCESS);
 }

 bool AvrcpTarget::SetVolume(int volume) {
   LockGuard lock(mutex_);
   TRY_RET_FUNC(
       hal::BluetoothAvrcpInterface::Get()->GetTargetHALInterface()->set_volume(
           volume) == BT_STATUS_SUCCESS);
 }

 void AvrcpTarget::RemoteFeaturesCallback(const RawAddress& bd_addr,
                                          btrc_remote_features_t features) {
   auto str_addr = BtAddrString(&bd_addr);
   LockGuard lock(delegate_mutex_);
   if (delegate_)
     delegate_->OnGetRemoteFeatures(str_addr, static_cast<int32_t>(features));
 }

 void AvrcpTarget::GetPlayStatusCallback(const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnGetPlayStatus(str_addr);
 }

 void AvrcpTarget::ListPlayerAppAttrCallback(const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnListPlayerAppAttr(str_addr);
 }

 void AvrcpTarget::ListPlayerAppValuesCallback(btrc_player_attr_t attr_id,
                                               const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   LockGuard lock(delegate_mutex_);
   if (delegate_)
     delegate_->OnListPlayerAppValues(str_addr, static_cast<int32_t>(attr_id));
 }

 void AvrcpTarget::GetPlayerAppValueCallback(uint8_t num_attr,
                                             btrc_player_attr_t* p_attrs,
                                             const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   std::vector<int32_t> attr_vec;
   attr_vec.reserve(num_attr);
   for (auto* it = p_attrs; it != p_attrs + num_attr; ++it) {
     attr_vec.push_back(*it);
   }

   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnGetPlayerAppValue(str_addr, attr_vec);
 }

 void AvrcpTarget::GetPlayerAppAttrsTextCallback(uint8_t num_attr,
                                                 btrc_player_attr_t* p_attrs,
                                                 const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   std::vector<int32_t> attr_vec;
   attr_vec.reserve(num_attr);
   for (auto* it = p_attrs; it != p_attrs + num_attr; ++it) {
     attr_vec.push_back(*it);
   }

   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnGetPlayerAppAttrsText(str_addr, attr_vec);
 }

 void AvrcpTarget::GetPlayerAppValuesTextCallback(uint8_t attr_id,
                                                  uint8_t num_val,
                                                  uint8_t* p_vals,
                                                  const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   std::vector<int32_t> val_vec;
   val_vec.reserve(num_val);
   for (auto* it = p_vals; it != p_vals + num_val; ++it) {
     val_vec.push_back(*it);
   }
   LockGuard lock(delegate_mutex_);
   if (delegate_)
     delegate_->OnGetPlayerAppValuesText(str_addr, attr_id, val_vec);
 }

 void AvrcpTarget::SetPlayerAppValueCallback(btrc_player_settings_t* p_vals,
                                             const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   std::vector<AvrcpIntValue> values;
   values.reserve(p_vals->num_attr);
   for (size_t i = 0; i < p_vals->num_attr; ++i) {
     values.emplace_back(p_vals->attr_ids[i], p_vals->attr_values[i]);
   }

   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnSetPlayerAppValue(str_addr, values);
 }

 void AvrcpTarget::GetElementAttrCallback(uint8_t num_attr,
                                          btrc_media_attr_t* p_attrs,
                                          const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   std::vector<int32_t> attr_vec;
   attr_vec.reserve(num_attr);
   for (auto* it = p_attrs; it != p_attrs + num_attr; ++it) {
     attr_vec.push_back(*it);
   }
   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnGetElementAttrs(str_addr, attr_vec);
 }

 void AvrcpTarget::RegisterNotificationCallback(btrc_event_id_t event_id,
                                                uint32_t param,
                                                const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   LockGuard lock(delegate_mutex_);
   if (delegate_)
     delegate_->OnRegisterNotification(str_addr, static_cast<int32_t>(event_id),
                                       param);
 }

 void AvrcpTarget::VolumeChangeCallback(uint8_t volume, uint8_t ctype,
                                        const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnVolumeChange(str_addr, volume, ctype);
 }

 void AvrcpTarget::PassthroughCmdCallback(int id, int key_state,
                                          const RawAddress& bd_addr) {
   auto str_addr = BtAddrString(&bd_addr);
   LockGuard lock(delegate_mutex_);
   if (delegate_) delegate_->OnPassThroughCommand(str_addr, id, key_state);
 }

 // AvrcpTargetFactory implementation
 // ========================================================

 AvrcpTargetFactory::AvrcpTargetFactory() = default;
 AvrcpTargetFactory::~AvrcpTargetFactory() = default;

 bool AvrcpTargetFactory::RegisterInstance(const Uuid& uuid,
                                           const RegisterCallback& callback) {
   VLOG(1) << __func__ << " - UUID: " << uuid.ToString();

   auto avrcp_target = base::WrapUnique(new AvrcpTarget(uuid));
   callback(BLE_STATUS_SUCCESS, uuid, std::move(avrcp_target));
   return true;
 }

 }  // namespace bluetooth
	//
	// Copyright (C) 2017 Google, Inc.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at:
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//

	#include "service/avrcp_target.h"

	#include <algorithm>
	#include <cerrno>
	#include <climits>
	#include <string>

	#include "base/logging.h"
	#include "base/macros.h"
	#include "base/memory/ptr_util.h"
	#include "service/logging_helpers.h"

	#include "array_utils.h"
	#include "stack/include/avrc_defs.h"

	#define PARSE_ADDR(str) \
	({ \
	RawAddress tmp; \
	if (!RawAddress::FromString((str), tmp)) { \
	LOG(ERROR) << "Invalid device address given: " << (str); \
	return false; \
	} \
	tmp; \
	})

	#define TRY_RET(expr, err_msg) \
	do { \
	if (!(expr)) { \
	LOG(ERROR) << err_msg; \
	return false; \
	} \
	return true; \
	} while (0)

	#define TRY_RET_FUNC(expr) TRY_RET(expr, __func__ << " failed")

	using LockGuard = std::lock_guard<std::mutex>;

	namespace bluetooth {

	namespace {

	std::vector<btrc_player_setting_text_t> StringValueToPlayerSettingsText(
	const std::vector<AvrcpStringValue>& attrs) {
	std::vector<btrc_player_setting_text_t> btrc_attrs(attrs.size());
	for (size_t i = 0; i < attrs.size(); ++i) {
	btrc_attrs[i].id = attrs[i].id();
	std::string str(attrs[i].value());
	size_t to_copy = std::min(sizeof(btrc_attrs[i].text) - 1, str.size());
	if (to_copy < str.size()) {
	LOG(WARNING) << "Value truncated";
	}

	memcpy(btrc_attrs[i].text, str.data(), to_copy);
	btrc_attrs[i].text[to_copy] = '\0';
	}

	return btrc_attrs;
	}

	std::vector<btrc_element_attr_val_t> StringValueToElementAttrVal(
	const std::vector<AvrcpStringValue>& attrs) {
	std::vector<btrc_element_attr_val_t> btrc_attrs(attrs.size());
	for (size_t i = 0; i < attrs.size(); ++i) {
	btrc_attrs[i].attr_id = attrs[i].id();
	std::string str(attrs[i].value());
	size_t to_copy = std::min(sizeof(btrc_attrs[i].text) - 1, str.size());
	if (to_copy < str.size()) {
	LOG(WARNING) << "Value truncated";
	}

	memcpy(btrc_attrs[i].text, str.data(), to_copy);
	btrc_attrs[i].text[to_copy] = '\0';
	}

	return btrc_attrs;
	}

	} // namespace

	// static
	const int AvrcpTarget::kSingletonInstanceId = 0;

	AvrcpTarget::AvrcpTarget(const Uuid& uuid) : app_identifier_(uuid) {
	hal::BluetoothAvrcpInterface::Get()->AddTargetObserver(this);
	}

	AvrcpTarget::~AvrcpTarget() {
	hal::BluetoothAvrcpInterface::Get()->RemoveTargetObserver(this);
	}

	const Uuid& AvrcpTarget::GetAppIdentifier() const { return app_identifier_; }

	int AvrcpTarget::GetInstanceId() const { return kSingletonInstanceId; }

	void AvrcpTarget::SetDelegate(Delegate* delegate) {
	LockGuard lock(delegate_mutex_);
	delegate_ = delegate;
	}

	bool AvrcpTarget::Enable() {
	LockGuard lock(mutex_);
	return hal::BluetoothAvrcpInterface::Get()->AvrcpTargetEnable();
	}

	void AvrcpTarget::Disable() {
	LockGuard lock(mutex_);
	hal::BluetoothAvrcpInterface::Get()->AvrcpTargetDisable();
	}

	bool AvrcpTarget::GetPlayStatusResponse(const std::string& str_addr,
	int32_t play_status, uint32_t song_len,
	uint32_t song_pos) {
	RawAddress addr = PARSE_ADDR(str_addr);
	LockGuard lock(mutex_);
	TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->get_play_status_rsp(
	addr, static_cast<btrc_play_status_t>(play_status),
	song_len, song_pos) == BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::ListPlayerAppAttrResponse(const std::string& str_addr,
	const std::vector<int32_t>& attrs) {
	RawAddress addr = PARSE_ADDR(str_addr);

	std::vector<btrc_player_attr_t> btrc_attrs;
	btrc_attrs.reserve(attrs.size());
	for (auto attr : attrs) {
	btrc_attrs.push_back(static_cast<btrc_player_attr_t>(attr));
	}

	LockGuard lock(mutex_);
	TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->list_player_app_attr_rsp(addr, btrc_attrs.size(),
	btrc_attrs.data()) ==
	BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::GetPlayerAppValueResponse(
	const std::string& str_addr, const std::vector<AvrcpIntValue>& values) {
	RawAddress addr = PARSE_ADDR(str_addr);
	btrc_player_settings_t btrc_values;
	if (values.size() >= ARRAY_SIZE(btrc_values.attr_ids)) {
	LOG(ERROR) << "Too many attribute values";
	return false;
	}

	btrc_values.num_attr = values.size();
	for (size_t i = 0; i < values.size(); ++i) {
	btrc_values.attr_ids[i] = values[i].id();
	btrc_values.attr_values[i] = values[i].value();
	}

	LockGuard lock(mutex_);
	TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->get_player_app_value_rsp(addr, &btrc_values) ==
	BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::GetPlayerAppAttrTextResponse(
	const std::string& str_addr, const std::vector<AvrcpStringValue>& attrs) {
	RawAddress addr = PARSE_ADDR(str_addr);
	auto btrc_attrs = StringValueToPlayerSettingsText(attrs);
	LockGuard lock(mutex_);
	TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->get_player_app_attr_text_rsp(addr, btrc_attrs.size(),
	btrc_attrs.data()) ==
	BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::GetPlayerAppValueTextResponse(
	const std::string& str_addr, const std::vector<AvrcpStringValue>& values) {
	RawAddress addr = PARSE_ADDR(str_addr);
	auto btrc_values = StringValueToPlayerSettingsText(values);
	LockGuard lock(mutex_);
	TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->get_player_app_value_text_rsp(addr, btrc_values.size(),
	btrc_values.data()) ==
	BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::GetElementAttrResponse(
	const std::string& str_addr, const std::vector<AvrcpStringValue>& attrs) {
	RawAddress addr = PARSE_ADDR(str_addr);
	auto btrc_attrs = StringValueToElementAttrVal(attrs);
	LockGuard lock(mutex_);
	TRY_RET_FUNC(
	hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->get_element_attr_rsp(addr, btrc_attrs.size(), btrc_attrs.data()) ==
	BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::SetPlayerAppValueResponse(const std::string& str_addr,
	int32_t rsp_status) {
	RawAddress addr = PARSE_ADDR(str_addr);
	LockGuard lock(mutex_);
	TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->set_player_app_value_rsp(
	addr, static_cast<btrc_status_t>(rsp_status)) ==
	BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::RegisterNotificationResponse(
	int32_t event_id, int32_t type,
	const AvrcpRegisterNotificationResponse& param) {
	auto param_copy = param.data();
	LockGuard lock(mutex_);
	TRY_RET_FUNC(hal::BluetoothAvrcpInterface::Get()
	->GetTargetHALInterface()
	->register_notification_rsp(
	static_cast<btrc_event_id_t>(event_id),
	static_cast<btrc_notification_type_t>(type),
	&param_copy) == BT_STATUS_SUCCESS);
	}

	bool AvrcpTarget::SetVolume(int volume) {
	LockGuard lock(mutex_);
	TRY_RET_FUNC(
	hal::BluetoothAvrcpInterface::Get()->GetTargetHALInterface()->set_volume(
	volume) == BT_STATUS_SUCCESS);
	}

	void AvrcpTarget::RemoteFeaturesCallback(const RawAddress& bd_addr,
	btrc_remote_features_t features) {
	auto str_addr = BtAddrString(&bd_addr);
	LockGuard lock(delegate_mutex_);
	if (delegate_)
	delegate_->OnGetRemoteFeatures(str_addr, static_cast<int32_t>(features));
	}

	void AvrcpTarget::GetPlayStatusCallback(const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnGetPlayStatus(str_addr);
	}

	void AvrcpTarget::ListPlayerAppAttrCallback(const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnListPlayerAppAttr(str_addr);
	}

	void AvrcpTarget::ListPlayerAppValuesCallback(btrc_player_attr_t attr_id,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	LockGuard lock(delegate_mutex_);
	if (delegate_)
	delegate_->OnListPlayerAppValues(str_addr, static_cast<int32_t>(attr_id));
	}

	void AvrcpTarget::GetPlayerAppValueCallback(uint8_t num_attr,
	btrc_player_attr_t* p_attrs,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	std::vector<int32_t> attr_vec;
	attr_vec.reserve(num_attr);
	for (auto* it = p_attrs; it != p_attrs + num_attr; ++it) {
	attr_vec.push_back(*it);
	}

	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnGetPlayerAppValue(str_addr, attr_vec);
	}

	void AvrcpTarget::GetPlayerAppAttrsTextCallback(uint8_t num_attr,
	btrc_player_attr_t* p_attrs,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	std::vector<int32_t> attr_vec;
	attr_vec.reserve(num_attr);
	for (auto* it = p_attrs; it != p_attrs + num_attr; ++it) {
	attr_vec.push_back(*it);
	}

	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnGetPlayerAppAttrsText(str_addr, attr_vec);
	}

	void AvrcpTarget::GetPlayerAppValuesTextCallback(uint8_t attr_id,
	uint8_t num_val,
	uint8_t* p_vals,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	std::vector<int32_t> val_vec;
	val_vec.reserve(num_val);
	for (auto* it = p_vals; it != p_vals + num_val; ++it) {
	val_vec.push_back(*it);
	}
	LockGuard lock(delegate_mutex_);
	if (delegate_)
	delegate_->OnGetPlayerAppValuesText(str_addr, attr_id, val_vec);
	}

	void AvrcpTarget::SetPlayerAppValueCallback(btrc_player_settings_t* p_vals,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	std::vector<AvrcpIntValue> values;
	values.reserve(p_vals->num_attr);
	for (size_t i = 0; i < p_vals->num_attr; ++i) {
	values.emplace_back(p_vals->attr_ids[i], p_vals->attr_values[i]);
	}

	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnSetPlayerAppValue(str_addr, values);
	}

	void AvrcpTarget::GetElementAttrCallback(uint8_t num_attr,
	btrc_media_attr_t* p_attrs,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	std::vector<int32_t> attr_vec;
	attr_vec.reserve(num_attr);
	for (auto* it = p_attrs; it != p_attrs + num_attr; ++it) {
	attr_vec.push_back(*it);
	}
	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnGetElementAttrs(str_addr, attr_vec);
	}

	void AvrcpTarget::RegisterNotificationCallback(btrc_event_id_t event_id,
	uint32_t param,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	LockGuard lock(delegate_mutex_);
	if (delegate_)
	delegate_->OnRegisterNotification(str_addr, static_cast<int32_t>(event_id),
	param);
	}

	void AvrcpTarget::VolumeChangeCallback(uint8_t volume, uint8_t ctype,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnVolumeChange(str_addr, volume, ctype);
	}

	void AvrcpTarget::PassthroughCmdCallback(int id, int key_state,
	const RawAddress& bd_addr) {
	auto str_addr = BtAddrString(&bd_addr);
	LockGuard lock(delegate_mutex_);
	if (delegate_) delegate_->OnPassThroughCommand(str_addr, id, key_state);
	}

	// AvrcpTargetFactory implementation
	// ========================================================

	AvrcpTargetFactory::AvrcpTargetFactory() = default;
	AvrcpTargetFactory::~AvrcpTargetFactory() = default;

	bool AvrcpTargetFactory::RegisterInstance(const Uuid& uuid,
	const RegisterCallback& callback) {
	VLOG(1) << __func__ << " - UUID: " << uuid.ToString();

	auto avrcp_target = base::WrapUnique(new AvrcpTarget(uuid));
	callback(BLE_STATUS_SUCCESS, uuid, std::move(avrcp_target));
	return true;
	}

	} // namespace bluetooth