Merge changes I40a016f2,Ic4ffb1a9,I06db70cc,Id3e7e1a4,Iab2c6d4c, ... into main (21ecd740) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/include/bta_le_audio_api.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -61,6 +61,7 @@ public:
	virtual void SetCodecConfigPreference(		virtual void SetCodecConfigPreference(
	int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,		int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,
	bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) = 0;		bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) = 0;
			virtual bool IsUsingPreferredCodecConfig(int group_id, int context_type) = 0;
	virtual void SetCcidInformation(int ccid, int context_type) = 0;		virtual void SetCcidInformation(int ccid, int context_type) = 0;
	virtual void SetInCall(bool in_call) = 0;		virtual void SetInCall(bool in_call) = 0;
	virtual bool IsInCall() = 0;		virtual bool IsInCall() = 0;

system/bta/le_audio/client.cc

+44 −2

Original line number	Original line	Diff line number	Diff line
	@@ -47,6 +47,7 @@
	#include "gatt_api.h"		#include "gatt_api.h"
	#include "hci/controller_interface.h"		#include "hci/controller_interface.h"
	#include "internal_include/stack_config.h"		#include "internal_include/stack_config.h"
			#include "le_audio/device_groups.h"
	#include "le_audio_health_status.h"		#include "le_audio_health_status.h"
	#include "le_audio_set_configuration_provider.h"		#include "le_audio_set_configuration_provider.h"
	#include "le_audio_types.h"		#include "le_audio_types.h"
	@@ -987,7 +988,45 @@ public:
	void SetCodecConfigPreference(		void SetCodecConfigPreference(
	int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,		int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,
	bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) override {		bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) override {
	// TODO Implement		if (!com::android::bluetooth::flags::leaudio_set_codec_config_preference()) {
			log::debug("leaudio_set_codec_config_preference flag is not enabled");
			return;
			}

			LeAudioDeviceGroup* group = aseGroups_.FindById(group_id);

			if (!group) {
			log::error("Unknown group id: %d", group_id);
			}

			if (group->SetPreferredAudioSetConfiguration(input_codec_config, output_codec_config)) {
			log::info("group id: {}, setting preferred codec is successful.", group_id);
			} else {
			log::warn("group id: {}, setting preferred codec is failed.", group_id);
			return;
			}

			if (group_id != active_group_id_) {
			log::warn("Selected group is not active.");
			return;
			}

			if (SetConfigurationAndStopStreamWhenNeeded(group, group->GetConfigurationContextType())) {
			log::debug("Group id {} do the reconfiguration based on preferred codec config", group_id);
			} else {
			log::debug("Group id {} preferred codec config is not changed", group_id);
			}
			}

			bool IsUsingPreferredCodecConfig(int group_id, int context_type) {
			LeAudioDeviceGroup* group = aseGroups_.FindById(group_id);
			if (!group) {
			log::error("Unknown group id: %d", group_id);
			return false;
			}

			return group->IsUsingPreferredAudioSetConfiguration(
			static_cast<LeAudioContextType>(context_type));
	}		}

	void SetCcidInformation(int ccid, int context_type) override {		void SetCcidInformation(int ccid, int context_type) override {
	@@ -4170,7 +4209,10 @@ public:

	inline bool IsDirectionAvailableForCurrentConfiguration(const LeAudioDeviceGroup* group,		inline bool IsDirectionAvailableForCurrentConfiguration(const LeAudioDeviceGroup* group,
	uint8_t direction) const {		uint8_t direction) const {
	auto current_config = group->GetCachedConfiguration(configuration_context_type_);		auto current_config =
			group->IsUsingPreferredAudioSetConfiguration(configuration_context_type_)
			? group->GetCachedPreferredConfiguration(configuration_context_type_)
			: group->GetCachedConfiguration(configuration_context_type_);
	if (current_config) {		if (current_config) {
	return current_config->confs.get(direction).size() != 0;		return current_config->confs.get(direction).size() != 0;
	}		}

system/bta/le_audio/device_groups.cc

+136 −19

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@
	#include "bta_csis_api.h"		#include "bta_csis_api.h"
	#include "btif/include/btif_profile_storage.h"		#include "btif/include/btif_profile_storage.h"
	#include "btm_iso_api.h"		#include "btm_iso_api.h"
			#include "common/strings.h"
	#include "hci/controller_interface.h"		#include "hci/controller_interface.h"
	#include "internal_include/bt_trace.h"		#include "internal_include/bt_trace.h"
	#include "le_audio/codec_manager.h"		#include "le_audio/codec_manager.h"
	@@ -868,6 +869,20 @@ LeAudioDeviceGroup::GetAudioSetConfigurationRequirements(types::LeAudioContextTy
	CodecManager::UnicastConfigurationRequirements::DeviceDirectionRequirements config_req;		CodecManager::UnicastConfigurationRequirements::DeviceDirectionRequirements config_req;
	config_req.params.Add(codec_spec_conf::kLeAudioLtvTypeAudioChannelAllocation,		config_req.params.Add(codec_spec_conf::kLeAudioLtvTypeAudioChannelAllocation,
	(uint32_t)locations);		(uint32_t)locations);
			if (preferred_config_.get(direction) &&
			preferred_config_.get(direction)->codec_priority != -1) {
			config_req.params.Add(
			codec_spec_conf::kLeAudioLtvTypeSamplingFreq,
			UINT8_TO_VEC_UINT8(codec_spec_conf::SingleSamplingFreqCapability2Config(
			preferred_config_.get(direction)->sample_rate)));
			config_req.params.Add(
			codec_spec_conf::kLeAudioLtvTypeFrameDuration,
			UINT8_TO_VEC_UINT8(codec_spec_conf::SingleFrameDurationCapability2Config(
			preferred_config_.get(direction)->frame_duration)));
			config_req.params.Add(
			codec_spec_conf::kLeAudioLtvTypeOctetsPerCodecFrame,
			UINT16_TO_VEC_UINT8(preferred_config_.get(direction)->octets_per_frame));
			}
	config_req.target_latency = utils::GetTargetLatencyForAudioContext(ctx_type);		config_req.target_latency = utils::GetTargetLatencyForAudioContext(ctx_type);
	log::warn("Device {} pushes requirement, location: {}, direction: {}", device->address_,		log::warn("Device {} pushes requirement, location: {}, direction: {}", device->address_,
	(int)locations, (int)direction);		(int)locations, (int)direction);
	@@ -902,38 +917,87 @@ LeAudioDeviceGroup::GetAudioSetConfigurationRequirements(types::LeAudioContextTy
	return new_req;		return new_req;
	}		}

	bool LeAudioDeviceGroup::UpdateAudioSetConfigurationCache(LeAudioContextType ctx_type) const {		bool LeAudioDeviceGroup::UpdateAudioSetConfigurationCache(LeAudioContextType ctx_type,
			bool use_preference) const {
	auto requirements = GetAudioSetConfigurationRequirements(ctx_type);		auto requirements = GetAudioSetConfigurationRequirements(ctx_type);
	auto new_conf = CodecManager::GetInstance()->GetCodecConfig(		auto new_conf = CodecManager::GetInstance()->GetCodecConfig(
	requirements, std::bind(&LeAudioDeviceGroup::FindFirstSupportedConfiguration, this,		requirements, std::bind(&LeAudioDeviceGroup::FindFirstSupportedConfiguration, this,
	std::placeholders::_1, std::placeholders::_2));		std::placeholders::_1, std::placeholders::_2, use_preference));
	auto update_config = true;		auto update_config = true;

	if (context_to_configuration_cache_map.count(ctx_type) != 0) {		auto& cached_map = use_preference ? context_to_preferred_configuration_cache_map_
	auto& [is_valid, existing_conf] = context_to_configuration_cache_map.at(ctx_type);		: context_to_configuration_cache_map_;

			if (cached_map.count(ctx_type) != 0) {
			auto& [is_valid, existing_conf] = cached_map.at(ctx_type);
	update_config = (new_conf.get() != existing_conf.get());		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;		cached_map.at(ctx_type).first = true;
	return false;		return false;
	}		}
	}		}

	if (update_config) {		if (update_config) {
	log::info("config: {} -> {}", ToHexString(ctx_type),		log::info("config: {} -> {}, use_preference: {}", ToHexString(ctx_type),
	(new_conf ? new_conf->name.c_str() : "(none)"));		(new_conf ? new_conf->name.c_str() : "(none)"), use_preference);
	context_to_configuration_cache_map.erase(ctx_type);		cached_map.erase(ctx_type);
	if (new_conf) {		if (new_conf) {
	context_to_configuration_cache_map.insert(		cached_map.insert(std::make_pair(ctx_type, std::make_pair(true, std::move(new_conf))));
	std::make_pair(ctx_type, std::make_pair(true, std::move(new_conf))));
	}		}
	}		}

	return update_config;		return update_config;
	}		}

			bool LeAudioDeviceGroup::SetPreferredAudioSetConfiguration(
			const bluetooth::le_audio::btle_audio_codec_config_t& input_codec_config,
			const bluetooth::le_audio::btle_audio_codec_config_t& output_codec_config) const {
			if (input_codec_config.codec_priority == -1 \|\| output_codec_config.codec_priority == -1) {
			log::info("Clear codec config");
			ResetPreferredAudioSetConfiguration();
			return true;
			}

			preferred_config_.sink = std::make_unique<btle_audio_codec_config_t>(output_codec_config);
			preferred_config_.source = std::make_unique<btle_audio_codec_config_t>(input_codec_config);

			bool is_updated = false;

			for (LeAudioContextType ctx_type : types::kLeAudioContextAllTypesArray) {
			is_updated \|= UpdateAudioSetConfigurationCache(ctx_type, true);
			}

			return is_updated;
			}

			bool LeAudioDeviceGroup::IsUsingPreferredAudioSetConfiguration(
			const LeAudioContextType& context_type) const {
			if (!preferred_config_.sink \|\| !preferred_config_.source) {
			log::assert_that(!preferred_config_.sink && !preferred_config_.source,
			"Preferred config should be null for both direction");
			return false;
			}

			if (preferred_config_.sink->codec_priority == -1 \|\|
			preferred_config_.source->codec_priority == -1) {
			return false;
			}

			return GetPreferredConfiguration(context_type).get();
			}

			void LeAudioDeviceGroup::ResetPreferredAudioSetConfiguration(void) const {
			log::info("Reset preferred configuration cached for all cotexts.");
			context_to_preferred_configuration_cache_map_.clear();
			preferred_config_.sink = nullptr;
			preferred_config_.source = nullptr;
			}

	void LeAudioDeviceGroup::InvalidateCachedConfigurations(void) {		void LeAudioDeviceGroup::InvalidateCachedConfigurations(void) {
	log::info("Group id: {}", group_id_);		log::info("Group id: {}", group_id_);
	context_to_configuration_cache_map.clear();		context_to_configuration_cache_map_.clear();
			ResetPreferredAudioSetConfiguration();
	}		}

	types::BidirectionalPair<AudioContexts> LeAudioDeviceGroup::GetLatestAvailableContexts() const {		types::BidirectionalPair<AudioContexts> LeAudioDeviceGroup::GetLatestAvailableContexts() const {
	@@ -1397,7 +1461,8 @@ bool CheckIfStrategySupported(types::LeAudioConfigurationStrategy strategy,
	*/		*/
	bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(		bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(
	const CodecManager::UnicastConfigurationRequirements& requirements,		const CodecManager::UnicastConfigurationRequirements& requirements,
	const set_configurations::AudioSetConfiguration* audio_set_conf) const {		const set_configurations::AudioSetConfiguration* audio_set_conf,
			bool use_preference) const {
	/* TODO For now: set ase if matching with first pac.		/* TODO For now: set ase if matching with first pac.
	* 1) We assume as well that devices will match requirements in order		* 1) We assume as well that devices will match requirements in order
	* e.g. 1 Device - 1 Requirement, 2 Device - 2 Requirement etc.		* e.g. 1 Device - 1 Requirement, 2 Device - 2 Requirement etc.
	@@ -1432,6 +1497,22 @@ bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(
	}		}
	}		}

			// Match with requirement first if we have
			if (use_preference) {
			auto& direction_req = (direction == types::kLeAudioDirectionSink)
			? requirements.sink_requirements
			: requirements.source_requirements;
			if (!direction_req.has_value() \|\| !preferred_config_.get(direction)) {
			return false;
			}
			if (!utils::IsAseConfigMatchedWithPreferredRequirements(
			ase_confs, direction_req.value(),
			codec_spec_conf::SingleChannelCountCapability2Config(
			preferred_config_.get(direction)->channel_count))) {
			return false;
			}
			}

	// In some tests we expect the configuration to be there even when the		// In some tests we expect the configuration to be there even when the
	// contexts are not supported. Then we might want to configure the device		// contexts are not supported. Then we might want to configure the device
	// but use UNSPECIFIED which is always supported (but can be unavailable)		// but use UNSPECIFIED which is always supported (but can be unavailable)
	@@ -1640,15 +1721,25 @@ bool LeAudioDeviceGroup::ConfigureAses(

	std::shared_ptr<const set_configurations::AudioSetConfiguration>		std::shared_ptr<const set_configurations::AudioSetConfiguration>
	LeAudioDeviceGroup::GetCachedConfiguration(LeAudioContextType context_type) const {		LeAudioDeviceGroup::GetCachedConfiguration(LeAudioContextType context_type) const {
	if (context_to_configuration_cache_map.count(context_type) != 0) {		if (context_to_configuration_cache_map_.count(context_type) != 0) {
	return context_to_configuration_cache_map.at(context_type).second;		return context_to_configuration_cache_map_.at(context_type).second;
			}
			return nullptr;
			}

			std::shared_ptr<const set_configurations::AudioSetConfiguration>
			LeAudioDeviceGroup::GetCachedPreferredConfiguration(LeAudioContextType context_type) const {
			if (context_to_preferred_configuration_cache_map_.count(context_type) != 0) {
			return context_to_preferred_configuration_cache_map_.at(context_type).second;
	}		}
	return nullptr;		return nullptr;
	}		}

	std::shared_ptr<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 IsUsingPreferredAudioSetConfiguration(configuration_context_type_)
			? GetCachedPreferredConfiguration(configuration_context_type_)
			: GetCachedConfiguration(configuration_context_type_);
	}		}

	std::shared_ptr<const set_configurations::AudioSetConfiguration>		std::shared_ptr<const set_configurations::AudioSetConfiguration>
	@@ -1657,12 +1748,17 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) const {
	return nullptr;		return nullptr;
	}		}

			if (IsUsingPreferredAudioSetConfiguration(context_type)) {
			log::debug("Using preferred codec config: {}", common::ToString(context_type));
			return GetCachedPreferredConfiguration(context_type);
			}

	const set_configurations::AudioSetConfiguration* conf = nullptr;		const set_configurations::AudioSetConfiguration* conf = nullptr;
	bool is_valid = false;		bool is_valid = false;

	/* 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) {
	auto& valid_config_pair = context_to_configuration_cache_map.at(context_type);		auto& valid_config_pair = context_to_configuration_cache_map_.at(context_type);
	is_valid = valid_config_pair.first;		is_valid = valid_config_pair.first;
	conf = valid_config_pair.second.get();		conf = valid_config_pair.second.get();
	}		}
	@@ -1673,6 +1769,27 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) const {
	return GetCachedConfiguration(context_type);		return GetCachedConfiguration(context_type);
	}		}

			std::shared_ptr<const set_configurations::AudioSetConfiguration>
			LeAudioDeviceGroup::GetPreferredConfiguration(LeAudioContextType context_type) const {
			if (context_type == LeAudioContextType::UNINITIALIZED) {
			return nullptr;
			}

			const set_configurations::AudioSetConfiguration* conf = nullptr;
			bool is_valid = false;

			if (context_to_preferred_configuration_cache_map_.count(context_type) != 0) {
			auto& valid_config_pair = context_to_preferred_configuration_cache_map_.at(context_type);
			is_valid = valid_config_pair.first;
			conf = valid_config_pair.second.get();
			}
			if (!is_valid \|\| conf == nullptr) {
			UpdateAudioSetConfigurationCache(context_type, true);
			}

			return GetCachedPreferredConfiguration(context_type);
			}

	LeAudioCodecConfiguration LeAudioDeviceGroup::GetAudioSessionCodecConfigForDirection(		LeAudioCodecConfiguration LeAudioDeviceGroup::GetAudioSessionCodecConfigForDirection(
	LeAudioContextType context_type, uint8_t direction) const {		LeAudioContextType context_type, uint8_t direction) const {
	auto audio_set_conf = GetConfiguration(context_type);		auto audio_set_conf = GetConfiguration(context_type);
	@@ -1909,7 +2026,7 @@ bool LeAudioDeviceGroup::IsConfiguredForContext(LeAudioContextType context_type)
	std::unique_ptr<set_configurations::AudioSetConfiguration>		std::unique_ptr<set_configurations::AudioSetConfiguration>
	LeAudioDeviceGroup::FindFirstSupportedConfiguration(		LeAudioDeviceGroup::FindFirstSupportedConfiguration(
	const CodecManager::UnicastConfigurationRequirements& requirements,		const CodecManager::UnicastConfigurationRequirements& requirements,
	const set_configurations::AudioSetConfigurations* confs) const {		const set_configurations::AudioSetConfigurations* confs, bool use_preference) const {
	log::assert_that(confs != nullptr, "confs should not be null");		log::assert_that(confs != nullptr, "confs should not be null");

	log::debug("context type: {}, number of connected devices: {}",		log::debug("context type: {}, number of connected devices: {}",
	@@ -1918,7 +2035,7 @@ LeAudioDeviceGroup::FindFirstSupportedConfiguration(
	/* Filter out device set for each end every scenario */		/* Filter out device set for each end every scenario */
	for (const auto& conf : *confs) {		for (const auto& conf : *confs) {
	log::assert_that(conf != nullptr, "confs should not be null");		log::assert_that(conf != nullptr, "confs should not be null");
	if (IsAudioSetConfigurationSupported(requirements, conf)) {		if (IsAudioSetConfigurationSupported(requirements, conf, use_preference)) {
	log::debug("found: {}", conf->name);		log::debug("found: {}", conf->name);
	return std::make_unique<set_configurations::AudioSetConfiguration>(*conf);		return std::make_unique<set_configurations::AudioSetConfiguration>(*conf);
	}		}

system/bta/le_audio/device_groups.h

+31 −4

Original line number	Original line	Diff line number	Diff line
	@@ -31,6 +31,8 @@
	#include <utility> // for std::pair		#include <utility> // for std::pair
	#include <vector>		#include <vector>

			#include "hardware/bt_le_audio.h"

	#ifdef __ANDROID__		#ifdef __ANDROID__
	#include <android/sysprop/BluetoothProperties.sysprop.h>		#include <android/sysprop/BluetoothProperties.sysprop.h>
	#endif		#endif
	@@ -124,6 +126,7 @@ public:
	group_user_allowed_context_mask_(		group_user_allowed_context_mask_(
	{.sink = types::AudioContexts(types::kLeAudioContextAllTypes),		{.sink = types::AudioContexts(types::kLeAudioContextAllTypes),
	.source = types::AudioContexts(types::kLeAudioContextAllTypes)}),		.source = types::AudioContexts(types::kLeAudioContextAllTypes)}),
			preferred_config_({.sink = nullptr, .source = nullptr}),
	target_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE),		target_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE),
	current_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE),		current_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE),
	in_transition_(false) {		in_transition_(false) {
	@@ -204,9 +207,15 @@ public:
	bool GetPresentationDelay(uint32_t* delay, uint8_t direction) const;		bool GetPresentationDelay(uint32_t* delay, uint8_t direction) const;
	uint16_t GetRemoteDelay(uint8_t direction) const;		uint16_t GetRemoteDelay(uint8_t direction) const;
	bool UpdateAudioContextAvailability(void);		bool UpdateAudioContextAvailability(void);
	bool UpdateAudioSetConfigurationCache(types::LeAudioContextType ctx_type) const;		bool UpdateAudioSetConfigurationCache(types::LeAudioContextType ctx_type,
			bool use_preferred = false) const;
	CodecManager::UnicastConfigurationRequirements GetAudioSetConfigurationRequirements(		CodecManager::UnicastConfigurationRequirements GetAudioSetConfigurationRequirements(
	types::LeAudioContextType ctx_type) const;		types::LeAudioContextType ctx_type) const;
			bool SetPreferredAudioSetConfiguration(
			const bluetooth::le_audio::btle_audio_codec_config_t& input_codec_config,
			const bluetooth::le_audio::btle_audio_codec_config_t& output_codec_config) const;
			bool IsUsingPreferredAudioSetConfiguration(const types::LeAudioContextType& context_type) const;
			void ResetPreferredAudioSetConfiguration(void) const;
	bool ReloadAudioLocations(void);		bool ReloadAudioLocations(void);
	bool ReloadAudioDirections(void);		bool ReloadAudioDirections(void);
	std::shared_ptr<const set_configurations::AudioSetConfiguration> GetActiveConfiguration(		std::shared_ptr<const set_configurations::AudioSetConfiguration> GetActiveConfiguration(
	@@ -214,8 +223,12 @@ public:
	bool IsPendingConfiguration(void) const;		bool IsPendingConfiguration(void) const;
	std::shared_ptr<const set_configurations::AudioSetConfiguration> GetConfiguration(		std::shared_ptr<const set_configurations::AudioSetConfiguration> GetConfiguration(
	types::LeAudioContextType ctx_type) const;		types::LeAudioContextType ctx_type) const;
			std::shared_ptr<const set_configurations::AudioSetConfiguration> GetPreferredConfiguration(
			types::LeAudioContextType ctx_type) const;
	std::shared_ptr<const set_configurations::AudioSetConfiguration> GetCachedConfiguration(		std::shared_ptr<const set_configurations::AudioSetConfiguration> GetCachedConfiguration(
	types::LeAudioContextType ctx_type) const;		types::LeAudioContextType ctx_type) const;
			std::shared_ptr<const set_configurations::AudioSetConfiguration> GetCachedPreferredConfiguration(
			types::LeAudioContextType ctx_type) const;
	void InvalidateCachedConfigurations(void);		void InvalidateCachedConfigurations(void);
	void SetPendingConfiguration(void);		void SetPendingConfiguration(void);
	void ClearPendingConfiguration(void);		void ClearPendingConfiguration(void);
	@@ -392,7 +405,7 @@ public:
	*/		*/
	std::unique_ptr<set_configurations::AudioSetConfiguration> FindFirstSupportedConfiguration(		std::unique_ptr<set_configurations::AudioSetConfiguration> FindFirstSupportedConfiguration(
	const CodecManager::UnicastConfigurationRequirements& requirements,		const CodecManager::UnicastConfigurationRequirements& requirements,
	const set_configurations::AudioSetConfigurations* confs) const;		const set_configurations::AudioSetConfigurations* confs, bool use_preferred) const;

	private:		private:
	bool is_enabled_;		bool is_enabled_;
	@@ -406,7 +419,8 @@ private:
	const types::BidirectionalPair<std::vector<uint8_t>>& ccid_lists);		const types::BidirectionalPair<std::vector<uint8_t>>& ccid_lists);
	bool IsAudioSetConfigurationSupported(		bool IsAudioSetConfigurationSupported(
	const CodecManager::UnicastConfigurationRequirements& requirements,		const CodecManager::UnicastConfigurationRequirements& requirements,
	const set_configurations::AudioSetConfiguration* audio_set_configuration) const;		const set_configurations::AudioSetConfiguration* audio_set_configuratio,
			bool use_preferred = false) const;
	uint32_t GetTransportLatencyUs(uint8_t direction) const;		uint32_t GetTransportLatencyUs(uint8_t direction) const;
	bool IsCisPartOfCurrentStream(uint16_t cis_conn_hdl) const;		bool IsCisPartOfCurrentStream(uint16_t cis_conn_hdl) const;

	@@ -438,7 +452,20 @@ private:
	mutable std::map<		mutable std::map<
	types::LeAudioContextType,		types::LeAudioContextType,
	std::pair<bool, const std::shared_ptr<set_configurations::AudioSetConfiguration>>>		std::pair<bool, const std::shared_ptr<set_configurations::AudioSetConfiguration>>>
	context_to_configuration_cache_map;		context_to_configuration_cache_map_;

			/* Possible preferred configuration cache - refreshed on each group context
			* availability change. Stored as a pair of (is_valid_cache, configuration*).
			* `pair.first` being `false` means that the cached value should be refreshed.
			*/
			mutable std::map<
			types::LeAudioContextType,
			std::pair<bool, const std::shared_ptr<set_configurations::AudioSetConfiguration>>>
			context_to_preferred_configuration_cache_map_;

			mutable types::BidirectionalPair<
			std::unique_ptr<const bluetooth::le_audio::btle_audio_codec_config_t>>
			preferred_config_;

	types::AseState target_state_;		types::AseState target_state_;
	types::AseState current_state_;		types::AseState current_state_;

system/bta/le_audio/devices_test.cc

+169 −2

File changed.

Preview size limit exceeded, changes collapsed.