Merge "LeAudio: Encapsulate CIG logic in LeAudioDeviceGroup" into main (a3ef3874) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/le_audio/client.cc

+4 −6

Original line number	Diff line number	Diff line
		@@ -487,7 +487,7 @@ class LeAudioClientImpl : public LeAudioClient {
		group_id, ToString(group->GetState()).c_str(),
		ToString(group->GetTargetState()).c_str(), check_if_recovery_needed);
		group->SetTargetState(AseState::BTA_LE_AUDIO_ASE_STATE_IDLE);
		group->CigClearCis();
		group->ClearAllCises();
		group->PrintDebugState();

		/* There is an issue with a setting up stream or any other operation which
		@@ -725,9 +725,9 @@ class LeAudioClientImpl : public LeAudioClient {
		}
		LOG_DEBUG("Group %p, id: %d, size: %d, is cig_state %s", group,
		group->group_id_, group->Size(),
		ToString(group->cig_state_).c_str());
		ToString(group->cig.GetState()).c_str());
		if (group->IsEmpty() &&
		(group->cig_state_ == le_audio::types::CigState::NONE)) {
		(group->cig.GetState() == le_audio::types::CigState::NONE)) {
		aseGroups_.Remove(group->group_id_);
		}
		}
		@@ -5374,9 +5374,7 @@ class LeAudioClientImpl : public LeAudioClient {
		LOG_ERROR("Invalid group_id: %d", group_id);
		return;
		}
		CodecManager::GetInstance()->UpdateCisConfiguration(
		group->cises_, group->stream_conf.stream_params.get(direction),
		direction);
		group->UpdateCisConfiguration(direction);
		}

		private:

system/bta/le_audio/device_groups.cc

+64 −97

Original line number	Diff line number	Diff line
		@@ -98,45 +98,32 @@ int LeAudioDeviceGroup::NumOfConnected(LeAudioContextType context_type) const {

		void LeAudioDeviceGroup::ClearSinksFromConfiguration(void) {
		LOG_INFO("Group %p, group_id %d", this, group_id_);
		auto direction = types::kLeAudioDirectionSink;

		auto& stream_params = stream_conf.stream_params.get(direction);
		stream_params.stream_locations.clear();
		stream_params.audio_channel_allocation = 0;
		stream_params.num_of_channels = 0;
		stream_params.num_of_devices = 0;
		stream_params.sample_frequency_hz = 0;
		stream_params.codec_frames_blocks_per_sdu = 0;
		stream_params.octets_per_codec_frame = 0;
		stream_params.frame_duration_us = 0;

		auto direction = types::kLeAudioDirectionSink;
		stream_conf.stream_params.get(direction).clear();
		CodecManager::GetInstance()->ClearCisConfiguration(direction);
		}

		void LeAudioDeviceGroup::ClearSourcesFromConfiguration(void) {
		LOG_INFO("Group %p, group_id %d", this, group_id_);
		auto direction = types::kLeAudioDirectionSource;

		auto& stream_params = stream_conf.stream_params.get(direction);
		stream_params.stream_locations.clear();
		stream_params.audio_channel_allocation = 0;
		stream_params.num_of_channels = 0;
		stream_params.num_of_devices = 0;
		stream_params.sample_frequency_hz = 0;
		stream_params.codec_frames_blocks_per_sdu = 0;
		stream_params.octets_per_codec_frame = 0;
		stream_params.frame_duration_us = 0;

		auto direction = types::kLeAudioDirectionSource;
		stream_conf.stream_params.get(direction).clear();
		CodecManager::GetInstance()->ClearCisConfiguration(direction);
		}

		void LeAudioDeviceGroup::CigClearCis(void) {
		void LeAudioDeviceGroup::ClearAllCises(void) {
		LOG_INFO("group_id: %d", group_id_);
		cises_.clear();
		cig.cises.clear();
		ClearSinksFromConfiguration();
		ClearSourcesFromConfiguration();
		}

		void LeAudioDeviceGroup::UpdateCisConfiguration(uint8_t direction) {
		CodecManager::GetInstance()->UpdateCisConfiguration(
		cig.cises, stream_conf.stream_params.get(direction), direction);
		}

		void LeAudioDeviceGroup::Cleanup(void) {
		/* Bluetooth is off while streaming - disconnect CISes and remove CIG */
		if (GetState() == AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING) {
		@@ -178,7 +165,7 @@ void LeAudioDeviceGroup::Cleanup(void) {
		*/

		leAudioDevices_.clear();
		this->CigClearCis();
		ClearAllCises();
		}

		void LeAudioDeviceGroup::Deactivate(void) {
		@@ -191,16 +178,6 @@ void LeAudioDeviceGroup::Deactivate(void) {
		}
		}

		le_audio::types::CigState LeAudioDeviceGroup::GetCigState(void) const {
		return cig_state_;
		}

		void LeAudioDeviceGroup::SetCigState(le_audio::types::CigState state) {
		LOG_VERBOSE("%s -> %s", bluetooth::common::ToString(cig_state_).c_str(),
		bluetooth::common::ToString(state).c_str());
		cig_state_ = state;
		}

		bool LeAudioDeviceGroup::Activate(
		LeAudioContextType context_type,
		const BidirectionalPair<AudioContexts>& metadata_context_types,
		@@ -215,7 +192,7 @@ bool LeAudioDeviceGroup::Activate(
		ADDRESS_TO_LOGGABLE_CSTR(leAudioDevice.lock().get()->address_),
		activated ? "activated" : " not activated");
		if (activated) {
		if (!CigAssignCisIds(leAudioDevice.lock().get())) {
		if (!cig.AssignCisIds(leAudioDevice.lock().get())) {
		return false;
		}
		is_activate = true;
		@@ -893,27 +870,12 @@ bool LeAudioDeviceGroup::HaveAllCisesDisconnected(void) const {
		return true;
		}

		uint8_t LeAudioDeviceGroup::GetFirstFreeCisId(void) const {
		for (uint8_t id = 0; id < UINT8_MAX; id++) {
		auto iter = std::find_if(leAudioDevices_.begin(), leAudioDevices_.end(),
		[id](auto& d) {
		if (d.expired())
		return false;
		else
		return ((d.lock()).get())->HasCisId(id);
		});

		if (iter == leAudioDevices_.end()) return id;
		}

		return kInvalidCisId;
		}

		uint8_t LeAudioDeviceGroup::GetFirstFreeCisId(CisType cis_type) const {
		LOG_INFO("Group: %p, group_id: %d cis_type: %d", this, group_id_,
		uint8_t LeAudioDeviceGroup::CigConfiguration::GetFirstFreeCisId(
		CisType cis_type) const {
		LOG_INFO("Group: %p, group_id: %d cis_type: %d", group_, group_->group_id_,
		static_cast<int>(cis_type));
		for (size_t id = 0; id < cises_.size(); id++) {
		if (cises_[id].addr.IsEmpty() && cises_[id].type == cis_type) {
		for (size_t id = 0; id < cises.size(); id++) {
		if (cises[id].addr.IsEmpty() && cises[id].type == cis_type) {
		return id;
		}
		}
		@@ -957,11 +919,13 @@ int LeAudioDeviceGroup::GetAseCount(uint8_t direction) const {
		return result;
		}

		void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) {
		LOG_INFO("Group %p, group_id: %d, context_type: %s", this, group_id_,
		void LeAudioDeviceGroup::CigConfiguration::GenerateCisIds(
		LeAudioContextType context_type) {
		LOG_INFO("Group %p, group_id: %d, context_type: %s", group_,
		group_->group_id_,
		bluetooth::common::ToString(context_type).c_str());

		if (cises_.size() > 0) {
		if (cises.size() > 0) {
		LOG_INFO("CIS IDs already generated");
		return;
		}
		@@ -976,16 +940,17 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) {

		if (bluetooth::csis::CsisClient::IsCsisClientRunning()) {
		csis_group_size =
		bluetooth::csis::CsisClient::Get()->GetDesiredSize(group_id_);
		bluetooth::csis::CsisClient::Get()->GetDesiredSize(group_->group_id_);
		}
		/* If this is CSIS group, the csis_group_size will be > 0, otherwise -1.
		* If the last happen it means, group size is 1 */
		int group_size = csis_group_size > 0 ? csis_group_size : 1;

		get_cis_count(*confs, group_size, GetGroupStrategy(group_size),
		GetAseCount(types::kLeAudioDirectionSink),
		GetAseCount(types::kLeAudioDirectionSource), cis_count_bidir,
		cis_count_unidir_sink, cis_count_unidir_source);
		get_cis_count(*confs, group_size, group_->GetGroupStrategy(group_size),
		group_->GetAseCount(types::kLeAudioDirectionSink),
		group_->GetAseCount(types::kLeAudioDirectionSource),
		cis_count_bidir, cis_count_unidir_sink,
		cis_count_unidir_source);

		uint8_t idx = 0;
		while (cis_count_bidir > 0) {
		@@ -995,7 +960,7 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) {
		.conn_handle = 0,
		.addr = RawAddress::kEmpty,
		};
		cises_.push_back(cis_entry);
		cises.push_back(cis_entry);
		cis_count_bidir--;
		idx++;
		}
		@@ -1007,7 +972,7 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) {
		.conn_handle = 0,
		.addr = RawAddress::kEmpty,
		};
		cises_.push_back(cis_entry);
		cises.push_back(cis_entry);
		cis_count_unidir_sink--;
		idx++;
		}
		@@ -1019,13 +984,14 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) {
		.conn_handle = 0,
		.addr = RawAddress::kEmpty,
		};
		cises_.push_back(cis_entry);
		cises.push_back(cis_entry);
		cis_count_unidir_source--;
		idx++;
		}
		}

		bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) {
		bool LeAudioDeviceGroup::CigConfiguration::AssignCisIds(
		LeAudioDevice* leAudioDevice) {
		ASSERT_LOG(leAudioDevice, "invalid device");
		LOG_INFO("device: %s", ADDRESS_TO_LOGGABLE_CSTR(leAudioDevice->address_));

		@@ -1041,8 +1007,8 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) {
		/* CIS ID already set */
		if (ase->cis_id != kInvalidCisId) {
		LOG_INFO("ASE ID: %d, is already assigned CIS ID: %d, type %d", ase->id,
		ase->cis_id, cises_[ase->cis_id].type);
		if (!cises_[ase->cis_id].addr.IsEmpty()) {
		ase->cis_id, cises[ase->cis_id].type);
		if (!cises[ase->cis_id].addr.IsEmpty()) {
		LOG_INFO("Bi-Directional CIS already assigned");
		continue;
		}
		@@ -1074,7 +1040,7 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) {
		if (cis_id != kInvalidCisId) {
		ase->cis_id = cis_id;
		matching_bidir_ase->cis_id = cis_id;
		cises_[cis_id].addr = leAudioDevice->address_;
		cises[cis_id].addr = leAudioDevice->address_;

		LOG_INFO(
		" ASE ID: %d and ASE ID: %d, assigned Bi-Directional CIS ID: %d",
		@@ -1108,7 +1074,7 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) {
		}

		ase->cis_id = cis_id;
		cises_[cis_id].addr = leAudioDevice->address_;
		cises[cis_id].addr = leAudioDevice->address_;
		LOG_INFO("ASE ID: %d, assigned Uni-Directional Sink CIS ID: %d", ase->id,
		ase->cis_id);
		continue;
		@@ -1137,7 +1103,7 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) {
		}

		ase->cis_id = cis_id;
		cises_[cis_id].addr = leAudioDevice->address_;
		cises[cis_id].addr = leAudioDevice->address_;
		LOG_INFO("ASE ID: %d, assigned Uni-Directional Source CIS ID: %d", ase->id,
		ase->cis_id);
		}
		@@ -1145,17 +1111,17 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) {
		return true;
		}

		void LeAudioDeviceGroup::CigAssignCisConnHandles(
		void LeAudioDeviceGroup::CigConfiguration::AssignCisConnHandles(
		const std::vector<uint16_t>& conn_handles) {
		LOG_INFO("num of cis handles %d", static_cast<int>(conn_handles.size()));
		for (size_t i = 0; i < cises_.size(); i++) {
		cises_[i].conn_handle = conn_handles[i];
		LOG_INFO("assigning cis[%d] conn_handle: %d", cises_[i].id,
		cises_[i].conn_handle);
		for (size_t i = 0; i < cises.size(); i++) {
		cises[i].conn_handle = conn_handles[i];
		LOG_INFO("assigning cis[%d] conn_handle: %d", cises[i].id,
		cises[i].conn_handle);
		}
		}

		void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses(
		void LeAudioDeviceGroup::AssignCisConnHandlesToAses(
		LeAudioDevice* leAudioDevice) {
		ASSERT_LOG(leAudioDevice, "Invalid device");
		LOG_INFO("group: %p, group_id: %d, device: %s", this, group_id_,
		@@ -1176,17 +1142,17 @@ void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses(
		auto ases_pair = leAudioDevice->GetAsesByCisId(ase->cis_id);

		if (ases_pair.sink && ases_pair.sink->active) {
		ases_pair.sink->cis_conn_hdl = cises_[ase->cis_id].conn_handle;
		ases_pair.sink->cis_conn_hdl = cig.cises[ase->cis_id].conn_handle;
		ases_pair.sink->cis_state = CisState::ASSIGNED;
		}
		if (ases_pair.source && ases_pair.source->active) {
		ases_pair.source->cis_conn_hdl = cises_[ase->cis_id].conn_handle;
		ases_pair.source->cis_conn_hdl = cig.cises[ase->cis_id].conn_handle;
		ases_pair.source->cis_state = CisState::ASSIGNED;
		}
		}
		}

		void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses(void) {
		void LeAudioDeviceGroup::AssignCisConnHandlesToAses(void) {
		LeAudioDevice* leAudioDevice = GetFirstActiveDevice();
		ASSERT_LOG(leAudioDevice, "Shouldn't be called without an active device.");

		@@ -1195,17 +1161,18 @@ void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses(void) {
		/* Assign all CIS connection handles to ases */
		for (; leAudioDevice != nullptr;
		leAudioDevice = GetNextActiveDevice(leAudioDevice)) {
		CigAssignCisConnHandlesToAses(leAudioDevice);
		AssignCisConnHandlesToAses(leAudioDevice);
		}
		}

		void LeAudioDeviceGroup::CigUnassignCis(LeAudioDevice* leAudioDevice) {
		void LeAudioDeviceGroup::CigConfiguration::UnassignCis(
		LeAudioDevice* leAudioDevice) {
		ASSERT_LOG(leAudioDevice, "Invalid device");

		LOG_INFO("Group %p, group_id %d, device: %s", this, group_id_,
		LOG_INFO("Group %p, group_id %d, device: %s", group_, group_->group_id_,
		ADDRESS_TO_LOGGABLE_CSTR(leAudioDevice->address_));

		for (struct le_audio::types::cis& cis_entry : cises_) {
		for (struct le_audio::types::cis& cis_entry : cises) {
		if (cis_entry.addr == leAudioDevice->address_) {
		cis_entry.addr = RawAddress::kEmpty;
		}
		@@ -1695,18 +1662,18 @@ void LeAudioDeviceGroup::RemoveCisFromStreamIfNeeded(
		/* Update CodecManager CIS configuration */
		if (old_sink_channels > stream_conf.stream_params.sink.num_of_channels) {
		CodecManager::GetInstance()->UpdateCisConfiguration(
		cises_,
		cig.cises,
		stream_conf.stream_params.get(le_audio::types::kLeAudioDirectionSink),
		le_audio::types::kLeAudioDirectionSink);
		}
		if (old_source_channels > stream_conf.stream_params.source.num_of_channels) {
		CodecManager::GetInstance()->UpdateCisConfiguration(
		cises_,
		cig.cises,
		stream_conf.stream_params.get(le_audio::types::kLeAudioDirectionSource),
		le_audio::types::kLeAudioDirectionSource);
		}

		CigUnassignCis(leAudioDevice);
		cig.UnassignCis(leAudioDevice);
		}

		bool LeAudioDeviceGroup::IsPendingConfiguration(void) const {
		@@ -1924,7 +1891,7 @@ void LeAudioDeviceGroup::PrintDebugState(void) const {
		<< ", state: " << bluetooth::common::ToString(GetState())
		<< ", target state: "
		<< bluetooth::common::ToString(GetTargetState())
		<< ", cig state: " << bluetooth::common::ToString(cig_state_)
		<< ", cig state: " << bluetooth::common::ToString(cig.GetState())
		<< ", \n group supported contexts: "
		<< bluetooth::common::ToString(GetSupportedContexts())
		<< ", \n group available contexts: "
		@@ -1934,9 +1901,9 @@ void LeAudioDeviceGroup::PrintDebugState(void) const {
		<< ", \n active configuration name: "
		<< (active_conf ? active_conf->name : " not set");

		if (cises_.size() > 0) {
		LOG_INFO("\n Allocated CISes: %d", static_cast<int>(cises_.size()));
		for (auto cis : cises_) {
		if (cig.cises.size() > 0) {
		LOG_INFO("\n Allocated CISes: %d", static_cast<int>(cig.cises.size()));
		for (auto cis : cig.cises) {
		LOG_INFO("\n cis id: %d, type: %d, conn_handle %d, addr: %s", cis.id,
		cis.type, cis.conn_handle, cis.addr.ToString().c_str());
		}
		@@ -1982,7 +1949,7 @@ void LeAudioDeviceGroup::Dump(int fd, int active_group_id) const {
		<< " == " << (is_active ? ",\tActive\n" : ",\tInactive\n")
		<< " state: " << GetState()
		<< ",\ttarget state: " << GetTargetState()
		<< ",\tcig state: " << cig_state_ << "\n"
		<< ",\tcig state: " << cig.GetState() << "\n"
		<< " group supported contexts: " << GetSupportedContexts() << "\n"
		<< " group available contexts: " << GetAvailableContexts() << "\n"
		<< " configuration context type: "
		@@ -2004,11 +1971,11 @@ void LeAudioDeviceGroup::Dump(int fd, int active_group_id) const {
		<< " num of sources(connected): "
		<< stream_conf.stream_params.source.num_of_devices << "("
		<< stream_conf.stream_params.source.stream_locations.size() << ")\n"
		<< " allocated CISes: " << static_cast<int>(cises_.size());
		<< " allocated CISes: " << static_cast<int>(cig.cises.size());

		if (cises_.size() > 0) {
		if (cig.cises.size() > 0) {
		stream << "\n\t == CISes == ";
		for (auto cis : cises_) {
		for (auto cis : cig.cises) {
		stream << "\n\t cis id: " << static_cast<int>(cis.id)
		<< ",\ttype: " << static_cast<int>(cis.type)
		<< ",\tconn_handle: " << static_cast<int>(cis.conn_handle)

system/bta/le_audio/device_groups.h

+31 −14

Original line number	Diff line number	Diff line
		@@ -44,7 +44,32 @@ class LeAudioDeviceGroup {
		public:
		const int group_id_;

		types::CigState cig_state_;
		class CigConfiguration {
		public:
		CigConfiguration() = delete;
		CigConfiguration(LeAudioDeviceGroup* group)
		: group_(group), state_(types::CigState::NONE) {}

		types::CigState GetState(void) const { return state_; }
		void SetState(le_audio::types::CigState state) {
		LOG_VERBOSE("%s -> %s", bluetooth::common::ToString(state_).c_str(),
		bluetooth::common::ToString(state).c_str());
		state_ = state;
		}

		void GenerateCisIds(types::LeAudioContextType context_type);
		bool AssignCisIds(LeAudioDevice* leAudioDevice);
		void AssignCisConnHandles(const std::vector<uint16_t>& conn_handles);
		void UnassignCis(LeAudioDevice* leAudioDevice);

		std::vector<struct types::cis> cises;

		private:
		uint8_t GetFirstFreeCisId(types::CisType cis_type) const;

		LeAudioDeviceGroup* group_;
		types::CigState state_;
		} cig;

		struct stream_configuration stream_conf;

		@@ -56,10 +81,9 @@ class LeAudioDeviceGroup {
		bool is_output_preference_le_audio;
		bool is_duplex_preference_le_audio;

		std::vector<struct types::cis> cises_;
		explicit LeAudioDeviceGroup(const int group_id)
		: group_id_(group_id),
		cig_state_(types::CigState::NONE),
		cig(this),
		stream_conf({}),
		audio_directions_(0),
		is_enabled_(true),
		@@ -106,9 +130,6 @@ class LeAudioDeviceGroup {
		metadata_context_types,
		types::BidirectionalPair<std::vector<uint8_t>> ccid_lists);
		void Deactivate(void);
		types::CigState GetCigState(void) const;
		void SetCigState(le_audio::types::CigState state);
		void CigClearCis(void);
		void ClearSinksFromConfiguration(void);
		void ClearSourcesFromConfiguration(void);
		void Cleanup(void);
		@@ -136,14 +157,10 @@ class LeAudioDeviceGroup {
		bool IsGroupReadyToCreateStream(void) const;
		bool IsGroupReadyToSuspendStream(void) const;
		bool HaveAllCisesDisconnected(void) const;
		uint8_t GetFirstFreeCisId(void) const;
		uint8_t GetFirstFreeCisId(types::CisType cis_type) const;
		void CigGenerateCisIds(types::LeAudioContextType context_type);
		bool CigAssignCisIds(LeAudioDevice* leAudioDevice);
		void CigAssignCisConnHandles(const std::vector<uint16_t>& conn_handles);
		void CigAssignCisConnHandlesToAses(LeAudioDevice* leAudioDevice);
		void CigAssignCisConnHandlesToAses(void);
		void CigUnassignCis(LeAudioDevice* leAudioDevice);
		void ClearAllCises(void);
		void UpdateCisConfiguration(uint8_t direction);
		void AssignCisConnHandlesToAses(LeAudioDevice* leAudioDevice);
		void AssignCisConnHandlesToAses(void);
		bool Configure(types::LeAudioContextType context_type,
		const types::BidirectionalPair<types::AudioContexts>&
		metadata_context_types,

system/bta/le_audio/devices.cc

+0 −37

Original line number	Diff line number	Diff line
		@@ -664,43 +664,6 @@ bool LeAudioDevice::HaveAnyCisConnected(void) {
		return false;
		}

		bool LeAudioDevice::HasCisId(uint8_t id) {
		struct ase* ase = GetFirstActiveAse();

		while (ase) {
		if (ase->cis_id == id) return true;
		ase = GetNextActiveAse(ase);
		}

		return false;
		}

		uint8_t LeAudioDevice::GetMatchingBidirectionCisId(const struct ase* base_ase) {
		for (auto& ase : ases_) {
		auto& cis = ase.cis_id;
		if (!ase.active) continue;

		int num_cises =
		std::count_if(ases_.begin(), ases_.end(), [&cis](const auto& iter_ase) {
		return iter_ase.active && iter_ase.cis_id == cis;
		});

		/*
		* If there is only one ASE for device with unique CIS ID and opposite to
		* direction - it may be bi-directional/completive.
		*/
		if (num_cises == 1 &&
		((base_ase->direction == types::kLeAudioDirectionSink &&
		ase.direction == types::kLeAudioDirectionSource) \|\|
		(base_ase->direction == types::kLeAudioDirectionSource &&
		ase.direction == types::kLeAudioDirectionSink))) {
		return ase.cis_id;
		}
		}

		return kInvalidCisId;
		}

		uint8_t LeAudioDevice::GetLc3SupportedChannelCount(uint8_t direction) {
		auto& pacs =
		direction == types::kLeAudioDirectionSink ? snk_pacs_ : src_pacs_;

system/bta/le_audio/devices.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -178,8 +178,6 @@ class LeAudioDevice {
		bool IsReadyToSuspendStream(void);
		bool HaveAllActiveAsesCisEst(void) const;
		bool HaveAnyCisConnected(void);
		bool HasCisId(uint8_t id);
		uint8_t GetMatchingBidirectionCisId(const struct types::ase* base_ase);
		const struct types::acs_ac_record* GetCodecConfigurationSupportedPac(
		uint8_t direction, const set_configurations::CodecCapabilitySetting&
		codec_capability_setting);