LeAudio: Configuration provider dependency inversion - Part 3 (07d6b997) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/le_audio/client.cc

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -3125,11 +3125,11 @@ class LeAudioClientImpl : public LeAudioClient {
	}		}

	auto num_of_devices =		auto num_of_devices =
	get_num_of_devices_in_configuration(stream_conf->conf);		get_num_of_devices_in_configuration(stream_conf->conf.get());

	if (num_of_devices < group->NumOfConnected() &&		if (num_of_devices < group->NumOfConnected() &&
	!group->IsAudioSetConfigurationSupported(leAudioDevice,		!group->IsAudioSetConfigurationSupported(leAudioDevice,
	stream_conf->conf)) {		stream_conf->conf.get())) {
	/* Reconfigure if newly connected member device cannot support current		/* Reconfigure if newly connected member device cannot support current
	* codec configuration */		* codec configuration */
	group->SetPendingConfiguration();		group->SetPendingConfiguration();

system/bta/le_audio/codec_manager.cc

+37 −7

Original line number	Original line	Diff line number	Diff line
	@@ -198,13 +198,38 @@ struct codec_manager_impl {
	}		}
	}		}

	const AudioSetConfigurations* GetOffloadCodecConfig(		const AudioSetConfigurations* GetSupportedCodecConfigurations(
	types::LeAudioContextType ctx_type) {		types::LeAudioContextType ctx_type) {
			if (GetCodecLocation() == le_audio::types::CodecLocation::ADSP) {
			LOG_VERBOSE("Get offload config for the context type: %d", (int)ctx_type);

			// TODO: Need to have a mechanism to switch to software session if offload
			// doesn't support.
	return context_type_offload_config_map_.count(ctx_type)		return context_type_offload_config_map_.count(ctx_type)
	? &context_type_offload_config_map_[ctx_type]		? &context_type_offload_config_map_[ctx_type]
	: nullptr;		: nullptr;
	}		}

			LOG_VERBOSE("Get software config for the context type: %d", (int)ctx_type);
			return AudioSetConfigurationProvider::Get()->GetConfigurations(ctx_type);
			}

			std::unique_ptr<AudioSetConfiguration> GetCodecConfig(
			types::LeAudioContextType ctx_type,
			std::function<const set_configurations::AudioSetConfiguration*(
			types::LeAudioContextType context_type,
			const set_configurations::AudioSetConfigurations* confs)>
			non_vendor_config_matcher) {
			// Note: For the only supported right now legacy software configuration
			// provider, we use the device group logic to match the proper
			// configuration with group capabilities. Note that this path only
			// supports the LC3 codec format. For the multicodec support we should
			// rely on the configuration matcher behind the AIDL interface.
			auto conf = non_vendor_config_matcher(
			ctx_type, GetSupportedCodecConfigurations(ctx_type));
			return conf ? std::make_unique<AudioSetConfiguration>(*conf) : nullptr;
			}

	bool CheckCodecConfigIsBiDirSwb(const AudioSetConfiguration& config) {		bool CheckCodecConfigIsBiDirSwb(const AudioSetConfiguration& config) {
	return AudioSetConfigurationProvider::Get()->CheckConfigurationIsBiDirSwb(		return AudioSetConfigurationProvider::Get()->CheckConfigurationIsBiDirSwb(
	config);		config);
	@@ -908,10 +933,15 @@ void CodecManager::UpdateActiveAudioConfig(
	stream_params, delays_ms, update_receiver);		stream_params, delays_ms, update_receiver);
	}		}

	const AudioSetConfigurations* CodecManager::GetOffloadCodecConfig(		std::unique_ptr<AudioSetConfiguration> CodecManager::GetCodecConfig(
	types::LeAudioContextType ctx_type) {		types::LeAudioContextType ctx_type,
			std::function<const set_configurations::AudioSetConfiguration*(
			types::LeAudioContextType context_type,
			const set_configurations::AudioSetConfigurations* confs)>
			non_vendor_config_matcher) {
	if (pimpl_->IsRunning()) {		if (pimpl_->IsRunning()) {
	return pimpl_->codec_manager_impl_->GetOffloadCodecConfig(ctx_type);		return pimpl_->codec_manager_impl_->GetCodecConfig(
			ctx_type, non_vendor_config_matcher);
	}		}

	return nullptr;		return nullptr;

system/bta/le_audio/codec_manager.h

+8 −4

Original line number	Original line	Diff line number	Diff line
	@@ -77,10 +77,14 @@ class CodecManager {
	types::BidirectionalPair<uint16_t> delays_ms,		types::BidirectionalPair<uint16_t> delays_ms,
	std::function<void(const offload_config& config, uint8_t direction)>		std::function<void(const offload_config& config, uint8_t direction)>
	update_receiver);		update_receiver);
	virtual const ::bluetooth::le_audio::set_configurations::		virtual std::unique_ptr<
	AudioSetConfigurations*		::bluetooth::le_audio::set_configurations::AudioSetConfiguration>
	GetOffloadCodecConfig(		GetCodecConfig(::bluetooth::le_audio::types::LeAudioContextType ctx_type,
	::bluetooth::le_audio::types::LeAudioContextType ctx_type);		std::function<const set_configurations::AudioSetConfiguration*(
			types::LeAudioContextType context_type,
			const set_configurations::AudioSetConfigurations* confs)>
			non_vendor_config_matcher);

	virtual bool CheckCodecConfigIsBiDirSwb(		virtual bool CheckCodecConfigIsBiDirSwb(
	const ::bluetooth::le_audio::set_configurations::AudioSetConfiguration&		const ::bluetooth::le_audio::set_configurations::AudioSetConfiguration&
	config) const;		config) const;

system/bta/le_audio/codec_manager_test.cc

+175 −3

Original line number	Original line	Diff line number	Diff line
	@@ -118,6 +118,45 @@ static const types::LeAudioCodecId kLeAudioCodecIdLc3 = {
	.vendor_company_id = types::kLeAudioVendorCompanyIdUndefined,		.vendor_company_id = types::kLeAudioVendorCompanyIdUndefined,
	.vendor_codec_id = types::kLeAudioVendorCodecIdUndefined};		.vendor_codec_id = types::kLeAudioVendorCodecIdUndefined};

			static const set_configurations::CodecConfigSetting lc3_16_2 = {
			.id = kLeAudioCodecIdLc3,
			.params = types::LeAudioLtvMap({
			LTV_ENTRY_SAMPLING_FREQUENCY(
			codec_spec_conf::kLeAudioSamplingFreq16000Hz),
			LTV_ENTRY_FRAME_DURATION(codec_spec_conf::kLeAudioCodecFrameDur10000us),
			LTV_ENTRY_AUDIO_CHANNEL_ALLOCATION(
			codec_spec_conf::kLeAudioLocationStereo),
			LTV_ENTRY_OCTETS_PER_CODEC_FRAME(40),
			}),
			.channel_count_per_iso_stream = 1,
			};

			static const set_configurations::CodecConfigSetting lc3_24_2 = {
			.id = kLeAudioCodecIdLc3,
			.params = types::LeAudioLtvMap({
			LTV_ENTRY_SAMPLING_FREQUENCY(
			codec_spec_conf::kLeAudioSamplingFreq24000Hz),
			LTV_ENTRY_FRAME_DURATION(codec_spec_conf::kLeAudioCodecFrameDur10000us),
			LTV_ENTRY_AUDIO_CHANNEL_ALLOCATION(
			codec_spec_conf::kLeAudioLocationStereo),
			LTV_ENTRY_OCTETS_PER_CODEC_FRAME(60),
			}),
			.channel_count_per_iso_stream = 1,
			};

			static const set_configurations::CodecConfigSetting lc3_32_2 = {
			.id = kLeAudioCodecIdLc3,
			.params = types::LeAudioLtvMap({
			LTV_ENTRY_SAMPLING_FREQUENCY(
			codec_spec_conf::kLeAudioSamplingFreq32000Hz),
			LTV_ENTRY_FRAME_DURATION(codec_spec_conf::kLeAudioCodecFrameDur10000us),
			LTV_ENTRY_AUDIO_CHANNEL_ALLOCATION(
			codec_spec_conf::kLeAudioLocationStereo),
			LTV_ENTRY_OCTETS_PER_CODEC_FRAME(80),
			}),
			.channel_count_per_iso_stream = 1,
			};

	static const set_configurations::CodecConfigSetting lc3_48_2 = {		static const set_configurations::CodecConfigSetting lc3_48_2 = {
	.id = kLeAudioCodecIdLc3,		.id = kLeAudioCodecIdLc3,
	.params = types::LeAudioLtvMap({		.params = types::LeAudioLtvMap({
	@@ -349,10 +388,23 @@ TEST_F(CodecManagerTestAdsp, test_capabilities_none) {
	offloading_preference(0);		offloading_preference(0);
	codec_manager->Start(offloading_preference);		codec_manager->Start(offloading_preference);

			auto match_first_config =
			[](types::LeAudioContextType context_type,
			const set_configurations::AudioSetConfigurations* confs)
			-> const set_configurations::AudioSetConfiguration* {
			if (confs && confs->size()) {
			// For simplicity return the first element, the real matcher should
			// check the group capabilities.
			return confs->at(0);
			}
			return nullptr;
			};

	// Verify every context		// Verify every context
	for (::bluetooth::le_audio::types::LeAudioContextType ctx_type :		for (::bluetooth::le_audio::types::LeAudioContextType ctx_type :
	::bluetooth::le_audio::types::kLeAudioContextAllTypesArray) {		::bluetooth::le_audio::types::kLeAudioContextAllTypesArray) {
	ASSERT_EQ(nullptr, codec_manager->GetOffloadCodecConfig(ctx_type));		ASSERT_EQ(nullptr,
			codec_manager->GetCodecConfig(ctx_type, match_first_config));
	}		}
	}		}

	@@ -379,9 +431,24 @@ TEST_F(CodecManagerTestAdsp, test_capabilities) {
	bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3}};		bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3}};
	codec_manager->Start(offloading_preference);		codec_manager->Start(offloading_preference);

	auto cfg = codec_manager->GetOffloadCodecConfig(test_context);		size_t available_configs_size = 0;
			auto match_first_config =
			[&available_configs_size](
			types::LeAudioContextType context_type,
			const set_configurations::AudioSetConfigurations* confs)
			-> const set_configurations::AudioSetConfiguration* {
			if (confs && confs->size()) {
			available_configs_size = confs->size();
			// For simplicity return the first element, the real matcher should
			// check the group capabilities.
			return confs->at(0);
			}
			return nullptr;
			};

			auto cfg = codec_manager->GetCodecConfig(test_context, match_first_config);
	ASSERT_NE(nullptr, cfg);		ASSERT_NE(nullptr, cfg);
	ASSERT_EQ(offload_capabilities.size(), cfg->size());		ASSERT_EQ(offload_capabilities.size(), available_configs_size);

	// Clean up the before testing any other offload capabilities.		// Clean up the before testing any other offload capabilities.
	codec_manager->Stop();		codec_manager->Stop();
	@@ -489,6 +556,111 @@ TEST_F(CodecManagerTestHost, test_start) {
	ASSERT_EQ(codec_manager->GetCodecLocation(), CodecLocation::HOST);		ASSERT_EQ(codec_manager->GetCodecLocation(), CodecLocation::HOST);
	}		}

			TEST_F(CodecManagerTestHost, test_non_bidir_swb) {
			const std::vector<bluetooth::le_audio::btle_audio_codec_config_t>
			offloading_preference = {
			{.codec_type = bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3}};
			codec_manager->Start(offloading_preference);

			// NON-SWB configs
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_16_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_24_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_16_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));

			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_16_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_32_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));

			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_24_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_24_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_32_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));

			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_16_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_24_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_32_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_48_2)}}));
			ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_48_2)}}));
			}

			TEST_F(CodecManagerTestHost, test_bidir_swb) {
			const std::vector<bluetooth::le_audio::btle_audio_codec_config_t>
			offloading_preference = {
			{.codec_type = bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3}};
			codec_manager->Start(offloading_preference);

			// SWB configs
			ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_32_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));
			ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_48_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));
			ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_32_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_48_2)}}));
			ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(
			{.confs = {set_configurations::SetConfiguration(
			types::kLeAudioDirectionSink, 1, 2, lc3_48_2),
			set_configurations::SetConfiguration(
			types::kLeAudioDirectionSource, 1, 2, lc3_48_2)}}));
			}

	TEST_F(CodecManagerTestHost, test_dont_update_broadcast_offloader) {		TEST_F(CodecManagerTestHost, test_dont_update_broadcast_offloader) {
	const std::vector<bluetooth::le_audio::btle_audio_codec_config_t>		const std::vector<bluetooth::le_audio::btle_audio_codec_config_t>
	offloading_preference = {		offloading_preference = {

system/bta/le_audio/device_groups.cc

+26 −20

Original line number	Original line	Diff line number	Diff line
	@@ -752,14 +752,15 @@ bool LeAudioDeviceGroup::UpdateAudioContextAvailability(void) {

	bool LeAudioDeviceGroup::UpdateAudioSetConfigurationCache(		bool LeAudioDeviceGroup::UpdateAudioSetConfigurationCache(
	LeAudioContextType ctx_type) {		LeAudioContextType ctx_type) {
	const bluetooth::le_audio::set_configurations::AudioSetConfiguration*		auto new_conf = CodecManager::GetInstance()->GetCodecConfig(
	new_conf = FindFirstSupportedConfiguration(ctx_type);		ctx_type, std::bind(&LeAudioDeviceGroup::FindFirstSupportedConfiguration,
			this, std::placeholders::_1, std::placeholders::_2));
	auto update_config = true;		auto update_config = true;

	if (context_to_configuration_cache_map.count(ctx_type) != 0) {		if (context_to_configuration_cache_map.count(ctx_type) != 0) {
	auto [is_valid, existing_conf] =		auto& [is_valid, existing_conf] =
	context_to_configuration_cache_map.at(ctx_type);		context_to_configuration_cache_map.at(ctx_type);
	update_config = (new_conf != existing_conf);		update_config = (new_conf.get() != existing_conf.get());
	/* Just mark it as still valid */		/* Just mark it as still valid */
	if (!update_config && !is_valid) {		if (!update_config && !is_valid) {
	context_to_configuration_cache_map.at(ctx_type).first = true;		context_to_configuration_cache_map.at(ctx_type).first = true;
	@@ -768,9 +769,12 @@ bool LeAudioDeviceGroup::UpdateAudioSetConfigurationCache(
	}		}

	if (update_config) {		if (update_config) {
	context_to_configuration_cache_map[ctx_type] = std::pair(true, new_conf);
	LOG_INFO("config: %s -> %s", ToHexString(ctx_type).c_str(),		LOG_INFO("config: %s -> %s", ToHexString(ctx_type).c_str(),
	(new_conf ? new_conf->name.c_str() : "(none)"));		(new_conf ? new_conf->name.c_str() : "(none)"));
			context_to_configuration_cache_map.erase(ctx_type);
			if (new_conf)
			context_to_configuration_cache_map.insert(
			std::make_pair(ctx_type, std::make_pair(true, std::move(new_conf))));
	}		}
	return update_config;		return update_config;
	}		}
	@@ -1468,7 +1472,7 @@ bool LeAudioDeviceGroup::ConfigureAses(
	return true;		return true;
	}		}

	const set_configurations::AudioSetConfiguration*		std::shared_ptr<const set_configurations::AudioSetConfiguration>
	LeAudioDeviceGroup::GetCachedConfiguration(		LeAudioDeviceGroup::GetCachedConfiguration(
	LeAudioContextType context_type) const {		LeAudioContextType context_type) const {
	if (context_to_configuration_cache_map.count(context_type) != 0) {		if (context_to_configuration_cache_map.count(context_type) != 0) {
	@@ -1477,12 +1481,12 @@ LeAudioDeviceGroup::GetCachedConfiguration(
	return nullptr;		return nullptr;
	}		}

	const set_configurations::AudioSetConfiguration*		std::shared_ptr<const set_configurations::AudioSetConfiguration>
	LeAudioDeviceGroup::GetActiveConfiguration(void) const {		LeAudioDeviceGroup::GetActiveConfiguration(void) const {
	return GetCachedConfiguration(configuration_context_type_);		return GetCachedConfiguration(configuration_context_type_);
	}		}

	const set_configurations::AudioSetConfiguration*		std::shared_ptr<const set_configurations::AudioSetConfiguration>
	LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) {		LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) {
	if (context_type == LeAudioContextType::UNINITIALIZED) {		if (context_type == LeAudioContextType::UNINITIALIZED) {
	return nullptr;		return nullptr;
	@@ -1493,8 +1497,10 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) {

	/* Refresh the cache if there is no valid configuration */		/* Refresh the cache if there is no valid configuration */
	if (context_to_configuration_cache_map.count(context_type) != 0) {		if (context_to_configuration_cache_map.count(context_type) != 0) {
	std::tie(is_valid, conf) =		auto& valid_config_pair =
	context_to_configuration_cache_map.at(context_type);		context_to_configuration_cache_map.at(context_type);
			is_valid = valid_config_pair.first;
			conf = valid_config_pair.second.get();
	}		}
	if (!is_valid \|\| (conf == nullptr)) {		if (!is_valid \|\| (conf == nullptr)) {
	UpdateAudioSetConfigurationCache(context_type);		UpdateAudioSetConfigurationCache(context_type);
	@@ -1506,8 +1512,7 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) {
	std::optional<LeAudioCodecConfiguration>		std::optional<LeAudioCodecConfiguration>
	LeAudioDeviceGroup::GetCachedCodecConfigurationByDirection(		LeAudioDeviceGroup::GetCachedCodecConfigurationByDirection(
	LeAudioContextType context_type, uint8_t direction) const {		LeAudioContextType context_type, uint8_t direction) const {
	const set_configurations::AudioSetConfiguration* audio_set_conf =		auto audio_set_conf = GetCachedConfiguration(context_type);
	GetCachedConfiguration(context_type);
	if (!audio_set_conf) return std::nullopt;		if (!audio_set_conf) return std::nullopt;

	LeAudioCodecConfiguration group_config = {0, 0, 0, 0};		LeAudioCodecConfiguration group_config = {0, 0, 0, 0};
	@@ -1561,8 +1566,10 @@ LeAudioDeviceGroup::GetCodecConfigurationByDirection(

	/* Refresh the cache if there is no valid configuration */		/* Refresh the cache if there is no valid configuration */
	if (context_to_configuration_cache_map.count(context_type) != 0) {		if (context_to_configuration_cache_map.count(context_type) != 0) {
	std::tie(is_valid, conf) =		auto& valid_config_pair =
	context_to_configuration_cache_map.at(context_type);		context_to_configuration_cache_map.at(context_type);
			is_valid = valid_config_pair.first;
			conf = valid_config_pair.second.get();
	}		}
	if (!is_valid \|\| (conf == nullptr)) {		if (!is_valid \|\| (conf == nullptr)) {
	UpdateAudioSetConfigurationCache(context_type);		UpdateAudioSetConfigurationCache(context_type);
	@@ -1795,7 +1802,7 @@ bool LeAudioDeviceGroup::IsConfiguredForContext(
	}		}

	/* Check if used configuration is same as the active one.*/		/* Check if used configuration is same as the active one.*/
	return (stream_conf.conf == GetActiveConfiguration());		return (stream_conf.conf.get() == GetActiveConfiguration().get());
	}		}

	bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(		bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(
	@@ -1820,10 +1827,8 @@ bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(

	const set_configurations::AudioSetConfiguration*		const set_configurations::AudioSetConfiguration*
	LeAudioDeviceGroup::FindFirstSupportedConfiguration(		LeAudioDeviceGroup::FindFirstSupportedConfiguration(
	LeAudioContextType context_type) const {		LeAudioContextType context_type,
	const set_configurations::AudioSetConfigurations* confs =		const set_configurations::AudioSetConfigurations* confs) const {
	AudioSetConfigurationProvider::Get()->GetConfigurations(context_type);

	LOG_DEBUG("context type: %s, number of connected devices: %d",		LOG_DEBUG("context type: %s, number of connected devices: %d",
	bluetooth::common::ToString(context_type).c_str(),		bluetooth::common::ToString(context_type).c_str(),
	+NumOfConnected());		+NumOfConnected());
	@@ -1872,7 +1877,8 @@ bool LeAudioDeviceGroup::Configure(
	LOG_DEBUG(" setting context type: %s",		LOG_DEBUG(" setting context type: %s",
	bluetooth::common::ToString(context_type).c_str());		bluetooth::common::ToString(context_type).c_str());

	if (!ConfigureAses(conf, context_type, metadata_context_types, ccid_lists)) {		if (!ConfigureAses(conf.get(), context_type, metadata_context_types,
			ccid_lists)) {
	LOG_ERROR(		LOG_ERROR(
	", requested context type: %s , is in mismatch with cached available "		", requested context type: %s , is in mismatch with cached available "
	"contexts",		"contexts",
	@@ -1890,7 +1896,7 @@ bool LeAudioDeviceGroup::Configure(
	LeAudioDeviceGroup::~LeAudioDeviceGroup(void) { this->Cleanup(); }		LeAudioDeviceGroup::~LeAudioDeviceGroup(void) { this->Cleanup(); }

	void LeAudioDeviceGroup::PrintDebugState(void) const {		void LeAudioDeviceGroup::PrintDebugState(void) const {
	auto* active_conf = GetActiveConfiguration();		auto active_conf = GetActiveConfiguration();
	std::stringstream debug_str;		std::stringstream debug_str;

	debug_str << "\n Groupd id: " << group_id_		debug_str << "\n Groupd id: " << group_id_
	@@ -1954,7 +1960,7 @@ void LeAudioDeviceGroup::PrintDebugState(void) const {
	void LeAudioDeviceGroup::Dump(int fd, int active_group_id) const {		void LeAudioDeviceGroup::Dump(int fd, int active_group_id) const {
	bool is_active = (group_id_ == active_group_id);		bool is_active = (group_id_ == active_group_id);
	std::stringstream stream, stream_pacs;		std::stringstream stream, stream_pacs;
	auto* active_conf = GetActiveConfiguration();		auto active_conf = GetActiveConfiguration();

	stream << "\n == Group id: " << group_id_		stream << "\n == Group id: " << group_id_
	<< (is_enabled_ ? " enabled" : " disabled")		<< (is_enabled_ ? " enabled" : " disabled")