Merge changes Ic9beb4af,Id4b77fd0,Ie541d871 into main am: d0662f4ce3 (dbf87c53) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/le_audio/client.cc

+43 −38

Original line number	Diff line number	Diff line
		@@ -365,6 +365,36 @@ public:
		}
		}

		void StartSuspendTimeout(void) {
		StopSuspendTimeout();

		/* Group should tie in time to get requested status */
		uint64_t timeoutMs = kAudioSuspentKeepIsoAliveTimeoutMs;
		timeoutMs = osi_property_get_int32(kAudioSuspentKeepIsoAliveTimeoutMsProp, timeoutMs);

		if (stack_config_get_interface()->get_pts_le_audio_disable_ases_before_stopping()) {
		timeoutMs += kAudioDisableTimeoutMs;
		}

		log::debug("Stream suspend_timeout_ started: {} ms", static_cast<int>(timeoutMs));

		alarm_set_on_mloop(
		suspend_timeout_, timeoutMs,
		[](void* data) {
		if (instance) {
		instance->GroupStop(PTR_TO_INT(data));
		}
		},
		INT_TO_PTR(active_group_id_));
		}

		void StopSuspendTimeout(void) {
		if (alarm_is_scheduled(suspend_timeout_)) {
		log::debug("Cancel suspend timeout");
		alarm_cancel(suspend_timeout_);
		}
		}

		void AseInitialStateReadRequest(LeAudioDevice* leAudioDevice) {
		int ases_num = leAudioDevice->ases_.size();
		void* notify_flag_ptr = NULL;
		@@ -1292,9 +1322,7 @@ public:
		sink_monitor_notified_status_ = std::nullopt;
		log::info("Group id: {}", active_group_id_);

		if (alarm_is_scheduled(suspend_timeout_)) {
		alarm_cancel(suspend_timeout_);
		}
		StopSuspendTimeout();

		StopAudio();
		ClientAudioInterfaceRelease();
		@@ -3921,9 +3949,7 @@ public:

		void Cleanup() {
		StopVbcCloseTimeout();
		if (alarm_is_scheduled(suspend_timeout_)) {
		alarm_cancel(suspend_timeout_);
		}
		StopSuspendTimeout();

		if (active_group_id_ != bluetooth::groups::kGroupUnknown) {
		/* Bluetooth turned off while streaming */
		@@ -4037,27 +4063,7 @@ public:
		INT_TO_PTR(active_group_id_));
		}

		/* Group should tie in time to get requested status */
		uint64_t timeoutMs = kAudioSuspentKeepIsoAliveTimeoutMs;
		timeoutMs = osi_property_get_int32(kAudioSuspentKeepIsoAliveTimeoutMsProp, timeoutMs);

		if (stack_config_get_interface()->get_pts_le_audio_disable_ases_before_stopping()) {
		timeoutMs += kAudioDisableTimeoutMs;
		}

		log::debug("Stream suspend_timeout_ started: {} ms", static_cast<int>(timeoutMs));
		if (alarm_is_scheduled(suspend_timeout_)) {
		alarm_cancel(suspend_timeout_);
		}

		alarm_set_on_mloop(
		suspend_timeout_, timeoutMs,
		[](void* data) {
		if (instance) {
		instance->GroupStop(PTR_TO_INT(data));
		}
		},
		INT_TO_PTR(active_group_id_));
		StartSuspendTimeout();
		}

		void OnLocalAudioSourceSuspend() {
		@@ -4215,6 +4221,7 @@ public:
		if (group->GetState() == AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING) {
		if (IsDirectionAvailableForCurrentConfiguration(
		group, bluetooth::le_audio::types::kLeAudioDirectionSink)) {
		StopSuspendTimeout();
		StartSendingAudio(active_group_id_);
		} else {
		log::warn(
		@@ -4255,9 +4262,7 @@ public:
		case AudioState::IDLE:
		case AudioState::READY_TO_RELEASE:
		/* Stream is up just restore it */
		if (alarm_is_scheduled(suspend_timeout_)) {
		alarm_cancel(suspend_timeout_);
		}
		StopSuspendTimeout();
		ConfirmLocalAudioSourceStreamingRequest();
		bluetooth::le_audio::MetricsCollector::Get()->OnStreamStarted(
		active_group_id_, configuration_context_type_);
		@@ -4282,8 +4287,6 @@ public:
		"r_state: " + ToString(audio_receiver_state_) +
		", s_state: " + ToString(audio_sender_state_));

		StartVbcCloseTimeout();

		/* Note: This callback is from audio hal driver.
		* Bluetooth peer is a Source for Audio Framework.
		* e.g. Peer is microphone.
		@@ -4308,6 +4311,11 @@ public:
		if ((audio_sender_state_ == AudioState::IDLE) \|\|
		(audio_sender_state_ == AudioState::READY_TO_RELEASE)) {
		OnAudioSuspend();
		} else {
		/* If the local sink direction is used, we want to monitor
		* if back channel is actually needed.
		*/
		StartVbcCloseTimeout();
		}

		log::info("OUT: audio_receiver_state_: {}, audio_sender_state_: {}",
		@@ -4468,6 +4476,7 @@ public:
		if (group->GetState() == AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING) {
		if (IsDirectionAvailableForCurrentConfiguration(
		group, bluetooth::le_audio::types::kLeAudioDirectionSource)) {
		StopSuspendTimeout();
		StartReceivingAudio(active_group_id_);
		} else {
		log::warn(
		@@ -4507,9 +4516,7 @@ public:
		case AudioState::READY_TO_START:
		case AudioState::READY_TO_RELEASE:
		/* Stream is up just restore it */
		if (alarm_is_scheduled(suspend_timeout_)) {
		alarm_cancel(suspend_timeout_);
		}
		StopSuspendTimeout();
		ConfirmLocalAudioSinkStreamingRequest();
		break;
		case AudioState::RELEASING:
		@@ -4604,9 +4611,7 @@ public:
		return false;
		}

		if (alarm_is_scheduled(suspend_timeout_)) {
		alarm_cancel(suspend_timeout_);
		}
		StopSuspendTimeout();

		/* Need to reconfigure stream. At this point pre_configuration_context_type shall be set */

system/bta/le_audio/le_audio_client_test.cc

+78 −0

Original line number	Diff line number	Diff line
		@@ -1442,6 +1442,7 @@ protected:
		void SetUp() override {
		__android_log_set_minimum_priority(ANDROID_LOG_VERBOSE);
		init_message_loop_thread();
		reset_mock_function_count_map();
		ON_CALL(controller_, SupportsBleConnectedIsochronousStreamCentral).WillByDefault(Return(true));
		ON_CALL(controller_, SupportsBleConnectedIsochronousStreamPeripheral)
		.WillByDefault(Return(true));
		@@ -9914,6 +9915,83 @@ TEST_F(UnicastTest, MicrophoneAttachToCurrentMediaScenario) {
		Mock::VerifyAndClearExpectations(mock_le_audio_source_hal_client_);
		}

		TEST_F(UnicastTest, SwitchBetweenMicrophoneAndSoundEffectScenario) {
		const RawAddress test_address0 = GetTestAddress(0);
		int group_id = bluetooth::groups::kGroupUnknown;

		/* Scenario:
		* 1. User starts Recording - this creates bidiretional CISes
		* 2. User stops recording - this starts suspend timeout (500ms)
		* 3. Since user touch the screen it generates touch tone - this shall reuse existing CISes when
		* it happens 500ms before stop
		*/
		SetSampleDatabaseEarbudsValid(1, test_address0, codec_spec_conf::kLeAudioLocationStereo,
		codec_spec_conf::kLeAudioLocationFrontLeft, default_channel_cnt,
		default_channel_cnt, 0x0024, false /add_csis/, true /add_cas/,
		true /add_pacs/, default_ase_cnt /add_ascs_cnt/, 1 /set_size/,
		0 /rank/);
		EXPECT_CALL(mock_audio_hal_client_callbacks_,
		OnConnectionState(ConnectionState::CONNECTED, test_address0))
		.Times(1);
		EXPECT_CALL(mock_audio_hal_client_callbacks_,
		OnGroupNodeStatus(test_address0, _, GroupNodeStatus::ADDED))
		.WillOnce(DoAll(SaveArg<1>(&group_id)));

		ConnectLeAudio(test_address0);
		ASSERT_NE(group_id, bluetooth::groups::kGroupUnknown);

		// Audio sessions are started only when device gets active
		EXPECT_CALL(*mock_le_audio_source_hal_client_, Start(_, _, _)).Times(1);
		EXPECT_CALL(*mock_le_audio_sink_hal_client_, Start(_, _, _)).Times(1);
		LeAudioClient::Get()->GroupSetActive(group_id);
		SyncOnMainLoop();

		// When the local audio source resumes we have no knowledge of recording
		EXPECT_CALL(mock_state_machine_,
		StartStream(_, bluetooth::le_audio::types::LeAudioContextType::LIVE, _, _))
		.Times(1);

		log::info("Start Microphone recording - bidirectional CISes are expected");
		UpdateLocalSinkMetadata(AUDIO_SOURCE_MIC);
		LocalAudioSinkResume();

		ASSERT_EQ(0, get_func_call_count("alarm_set_on_mloop"));
		SyncOnMainLoop();

		Mock::VerifyAndClearExpectations(&mock_audio_hal_client_callbacks_);
		Mock::VerifyAndClearExpectations(mock_le_audio_source_hal_client_);
		Mock::VerifyAndClearExpectations(&mock_state_machine_);

		// Verify Data transfer on one audio source cis
		uint8_t cis_count_out = 0;
		uint8_t cis_count_in = 1;
		TestAudioDataTransfer(group_id, cis_count_out, cis_count_in, 1920, 60);

		log::info("Suspend microphone recording - suspend timeout is not fired");
		LocalAudioSinkSuspend();
		SyncOnMainLoop();

		// VBC and Suspend
		ASSERT_EQ(1, get_func_call_count("alarm_set_on_mloop"));
		ASSERT_EQ(0, get_func_call_count("alarm_cancel"));

		log::info("Resume local source with touch tone - expect suspend timeout to be canceled");

		UpdateLocalSourceMetadata(AUDIO_USAGE_ASSISTANCE_SONIFICATION, AUDIO_CONTENT_TYPE_SONIFICATION);
		LocalAudioSourceResume();
		SyncOnMainLoop();

		ASSERT_EQ(1, get_func_call_count("alarm_cancel"));

		auto group = streaming_groups.at(group_id);
		group->PrintDebugState();

		// Verify Data transfer on one audio source and sink cis
		cis_count_out = 1;
		cis_count_in = 0;
		TestAudioDataTransfer(group_id, cis_count_out, cis_count_in, 1920, 60);
		}

		/* When a certain context is unavailable and not supported we should stream
		* as UNSPECIFIED for the backwards compatibility.
		* Since UNSPECIFIED is available, put the UNSPECIFIED into the metadata instead

system/bta/test/common/fake_osi.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include "osi/include/alarm.h"

		struct fake_osi_alarm_set_on_mloop {
		alarm_t* alarm;
		uint64_t interval_ms{0};
		alarm_callback_t cb{};
		void* data{nullptr};

system/test/stub/osi.cc

+60 −5

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@

		#include "osi/include/osi.h"

		#include <bluetooth/log.h>
		#include <sys/socket.h>

		#include <list>
		@@ -335,24 +336,70 @@ alarm_t* alarm_new_periodic(const char* name) {
		inc_func_call_count(__func__);
		return nullptr;
		}

		// Callback to last set alarm
		struct fake_osi_alarm_set_on_mloop fake_osi_alarm_set_on_mloop_;

		// Vector of previous osi alarms. Keep it for proper handling alarm_is_scheduler function
		static std::vector<struct fake_osi_alarm_set_on_mloop> previous_fake_osi_alarms_;

		bool alarm_is_scheduled(const alarm_t* alarm) {
		inc_func_call_count(__func__);
		return fake_osi_alarm_set_on_mloop_.cb != nullptr;

		auto iter =
		find_if(previous_fake_osi_alarms_.begin(), previous_fake_osi_alarms_.end(),
		[alarm](auto const& a) {
		bluetooth::log::debug("iter: {} == {} ?", fmt::ptr(a.alarm), fmt::ptr(alarm));
		return a.alarm == alarm;
		});
		if (iter != previous_fake_osi_alarms_.end()) {
		return true;
		}

		bluetooth::log::debug(" {} == {} ?", fmt::ptr(fake_osi_alarm_set_on_mloop_.alarm),
		fmt::ptr(alarm));

		return fake_osi_alarm_set_on_mloop_.alarm == alarm;
		}
		uint64_t alarm_get_remaining_ms(const alarm_t* alarm) {
		inc_func_call_count(__func__);
		return 0;
		}
		void alarm_cancel(alarm_t* alarm) {
		inc_func_call_count(__func__);

		static void fake_osi_alarm_clear(alarm_t* alarm) {
		if (alarm != nullptr) {
		auto iter = find_if(previous_fake_osi_alarms_.begin(), previous_fake_osi_alarms_.end(),
		[alarm](auto const& a) { return a.alarm == alarm; });
		if (iter != previous_fake_osi_alarms_.end()) {
		bluetooth::log::debug(" clearing alarm {} ", fmt::ptr(iter->alarm));
		previous_fake_osi_alarms_.erase(iter);
		return;
		}
		}

		if (fake_osi_alarm_set_on_mloop_.alarm == alarm \|\| alarm == nullptr) {
		bluetooth::log::debug(" clearing alarm {} ", fmt::ptr(alarm));
		fake_osi_alarm_set_on_mloop_.alarm = nullptr;
		fake_osi_alarm_set_on_mloop_.interval_ms = 0;
		fake_osi_alarm_set_on_mloop_.cb = nullptr;
		fake_osi_alarm_set_on_mloop_.data = nullptr;
		}
		void alarm_cleanup(void) { inc_func_call_count(__func__); }
		}

		void alarm_cancel(alarm_t* alarm) {
		inc_func_call_count(__func__);
		fake_osi_alarm_clear(alarm);
		}

		void alarm_cleanup(void) {
		previous_fake_osi_alarms_.clear();
		fake_osi_alarm_clear(nullptr);

		inc_func_call_count(__func__);
		}
		void alarm_debug_dump(int fd) { inc_func_call_count(__func__); }
		void alarm_free(alarm_t* alarm) {
		fake_osi_alarm_clear(alarm);
		uint8_t* ptr = (uint8_t*)alarm;
		delete[] ptr;
		inc_func_call_count(__func__);
		@@ -363,6 +410,14 @@ void alarm_set(alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb, void*

		void alarm_set_on_mloop(alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb, void* data) {
		inc_func_call_count(__func__);

		if (fake_osi_alarm_set_on_mloop_.alarm != nullptr) {
		bluetooth::log::info("Queuing alarm {}", fmt::ptr(fake_osi_alarm_set_on_mloop_.alarm));
		previous_fake_osi_alarms_.push_back(fake_osi_alarm_set_on_mloop_);
		}

		bluetooth::log::info("Adding alarm {}", fmt::ptr(alarm));
		fake_osi_alarm_set_on_mloop_.alarm = alarm;
		fake_osi_alarm_set_on_mloop_.interval_ms = interval_ms;
		fake_osi_alarm_set_on_mloop_.cb = cb;
		fake_osi_alarm_set_on_mloop_.data = data;