Merge changes I40a016f2,Ic4ffb1a9,I06db70cc,Id3e7e1a4,Iab2c6d4c, ... into main am: 21ecd74038 (7aabef3a) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/include/bta_le_audio_api.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -61,6 +61,7 @@ public:
		virtual void SetCodecConfigPreference(
		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;
		virtual bool IsUsingPreferredCodecConfig(int group_id, int context_type) = 0;
		virtual void SetCcidInformation(int ccid, int context_type) = 0;
		virtual void SetInCall(bool in_call) = 0;
		virtual bool IsInCall() = 0;

system/bta/le_audio/client.cc

+44 −2

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@
		#include "gatt_api.h"
		#include "hci/controller_interface.h"
		#include "internal_include/stack_config.h"
		#include "le_audio/device_groups.h"
		#include "le_audio_health_status.h"
		#include "le_audio_set_configuration_provider.h"
		#include "le_audio_types.h"
		@@ -987,7 +988,45 @@ public:
		void SetCodecConfigPreference(
		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 {
		// 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 {
		@@ -4170,7 +4209,10 @@ public:

		inline bool IsDirectionAvailableForCurrentConfiguration(const LeAudioDeviceGroup* group,
		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) {
		return current_config->confs.get(direction).size() != 0;
		}

system/bta/le_audio/device_groups.cc

+136 −19

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include "bta_csis_api.h"
		#include "btif/include/btif_profile_storage.h"
		#include "btm_iso_api.h"
		#include "common/strings.h"
		#include "hci/controller_interface.h"
		#include "internal_include/bt_trace.h"
		#include "le_audio/codec_manager.h"
		@@ -868,6 +869,20 @@ LeAudioDeviceGroup::GetAudioSetConfigurationRequirements(types::LeAudioContextTy
		CodecManager::UnicastConfigurationRequirements::DeviceDirectionRequirements config_req;
		config_req.params.Add(codec_spec_conf::kLeAudioLtvTypeAudioChannelAllocation,
		(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);
		log::warn("Device {} pushes requirement, location: {}, direction: {}", device->address_,
		(int)locations, (int)direction);
		@@ -902,38 +917,87 @@ LeAudioDeviceGroup::GetAudioSetConfigurationRequirements(types::LeAudioContextTy
		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 new_conf = CodecManager::GetInstance()->GetCodecConfig(
		requirements, std::bind(&LeAudioDeviceGroup::FindFirstSupportedConfiguration, this,
		std::placeholders::_1, std::placeholders::_2));
		std::placeholders::_1, std::placeholders::_2, use_preference));
		auto update_config = true;

		if (context_to_configuration_cache_map.count(ctx_type) != 0) {
		auto& [is_valid, existing_conf] = context_to_configuration_cache_map.at(ctx_type);
		auto& cached_map = use_preference ? context_to_preferred_configuration_cache_map_
		: 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());
		/* Just mark it as still 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;
		}
		}

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

		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) {
		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 {
		@@ -1397,7 +1461,8 @@ bool CheckIfStrategySupported(types::LeAudioConfigurationStrategy strategy,
		*/
		bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(
		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.
		* 1) We assume as well that devices will match requirements in order
		* 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
		// contexts are not supported. Then we might want to configure the device
		// 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>
		LeAudioDeviceGroup::GetCachedConfiguration(LeAudioContextType context_type) const {
		if (context_to_configuration_cache_map.count(context_type) != 0) {
		return context_to_configuration_cache_map.at(context_type).second;
		if (context_to_configuration_cache_map_.count(context_type) != 0) {
		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;
		}

		std::shared_ptr<const set_configurations::AudioSetConfiguration>
		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>
		@@ -1657,12 +1748,17 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) const {
		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;
		bool is_valid = false;

		/* Refresh the cache if there is no valid configuration */
		if (context_to_configuration_cache_map.count(context_type) != 0) {
		auto& valid_config_pair = context_to_configuration_cache_map.at(context_type);
		if (context_to_configuration_cache_map_.count(context_type) != 0) {
		auto& valid_config_pair = context_to_configuration_cache_map_.at(context_type);
		is_valid = valid_config_pair.first;
		conf = valid_config_pair.second.get();
		}
		@@ -1673,6 +1769,27 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) const {
		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(
		LeAudioContextType context_type, uint8_t direction) const {
		auto audio_set_conf = GetConfiguration(context_type);
		@@ -1909,7 +2026,7 @@ bool LeAudioDeviceGroup::IsConfiguredForContext(LeAudioContextType context_type)
		std::unique_ptr<set_configurations::AudioSetConfiguration>
		LeAudioDeviceGroup::FindFirstSupportedConfiguration(
		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::debug("context type: {}, number of connected devices: {}",
		@@ -1918,7 +2035,7 @@ LeAudioDeviceGroup::FindFirstSupportedConfiguration(
		/* Filter out device set for each end every scenario */
		for (const auto& conf : *confs) {
		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);
		return std::make_unique<set_configurations::AudioSetConfiguration>(*conf);
		}

system/bta/le_audio/device_groups.h

+31 −4

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

		#include "hardware/bt_le_audio.h"

		#ifdef __ANDROID__
		#include <android/sysprop/BluetoothProperties.sysprop.h>
		#endif
		@@ -124,6 +126,7 @@ public:
		group_user_allowed_context_mask_(
		{.sink = 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),
		current_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE),
		in_transition_(false) {
		@@ -204,9 +207,15 @@ public:
		bool GetPresentationDelay(uint32_t* delay, uint8_t direction) const;
		uint16_t GetRemoteDelay(uint8_t direction) const;
		bool UpdateAudioContextAvailability(void);
		bool UpdateAudioSetConfigurationCache(types::LeAudioContextType ctx_type) const;
		bool UpdateAudioSetConfigurationCache(types::LeAudioContextType ctx_type,
		bool use_preferred = false) const;
		CodecManager::UnicastConfigurationRequirements GetAudioSetConfigurationRequirements(
		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 ReloadAudioDirections(void);
		std::shared_ptr<const set_configurations::AudioSetConfiguration> GetActiveConfiguration(
		@@ -214,8 +223,12 @@ public:
		bool IsPendingConfiguration(void) const;
		std::shared_ptr<const set_configurations::AudioSetConfiguration> GetConfiguration(
		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(
		types::LeAudioContextType ctx_type) const;
		std::shared_ptr<const set_configurations::AudioSetConfiguration> GetCachedPreferredConfiguration(
		types::LeAudioContextType ctx_type) const;
		void InvalidateCachedConfigurations(void);
		void SetPendingConfiguration(void);
		void ClearPendingConfiguration(void);
		@@ -392,7 +405,7 @@ public:
		*/
		std::unique_ptr<set_configurations::AudioSetConfiguration> FindFirstSupportedConfiguration(
		const CodecManager::UnicastConfigurationRequirements& requirements,
		const set_configurations::AudioSetConfigurations* confs) const;
		const set_configurations::AudioSetConfigurations* confs, bool use_preferred) const;

		private:
		bool is_enabled_;
		@@ -406,7 +419,8 @@ private:
		const types::BidirectionalPair<std::vector<uint8_t>>& ccid_lists);
		bool IsAudioSetConfigurationSupported(
		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;
		bool IsCisPartOfCurrentStream(uint16_t cis_conn_hdl) const;

		@@ -438,7 +452,20 @@ private:
		mutable std::map<
		types::LeAudioContextType,
		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 current_state_;

system/bta/le_audio/devices_test.cc

+169 −2

File changed.

Preview size limit exceeded, changes collapsed.