Merge "Remove FROM_HERE from do_in_jni_thread invocations" into main (0a29f8bb) · Commits · e / os / android_packages_modules_Bluetooth

system/btif/avrcp/avrcp_service.cc

+35 −39

Original line number	Diff line number	Diff line
		@@ -45,10 +45,6 @@ namespace avrcp {
		AvrcpService* AvrcpService::instance_ = nullptr;
		AvrcpService::ServiceInterfaceImpl* AvrcpService::service_interface_ = nullptr;

		void do_in_avrcp_jni(const base::Closure& task) {
		do_in_jni_thread(FROM_HERE, task);
		}

		class A2dpInterfaceImpl : public A2dpInterface {
		RawAddress active_peer() override { return btif_av_source_active_peer(); }

		@@ -180,7 +176,7 @@ class MediaInterfaceWrapper : public MediaInterface {
		MediaInterfaceWrapper(MediaInterface* cb) : wrapped_(cb){};

		void SendKeyEvent(uint8_t key, KeyState state) override {
		do_in_avrcp_jni(base::Bind(&MediaInterface::SendKeyEvent,
		do_in_jni_thread(base::Bind(&MediaInterface::SendKeyEvent,
		base::Unretained(wrapped_), key, state));
		}

		@@ -191,7 +187,7 @@ class MediaInterfaceWrapper : public MediaInterface {

		auto bound_cb = base::Bind(cb_lambda, info_cb);

		do_in_avrcp_jni(base::Bind(&MediaInterface::GetSongInfo,
		do_in_jni_thread(base::Bind(&MediaInterface::GetSongInfo,
		base::Unretained(wrapped_), bound_cb));
		}

		@@ -202,7 +198,7 @@ class MediaInterfaceWrapper : public MediaInterface {

		auto bound_cb = base::Bind(cb_lambda, status_cb);

		do_in_avrcp_jni(base::Bind(&MediaInterface::GetPlayStatus,
		do_in_jni_thread(base::Bind(&MediaInterface::GetPlayStatus,
		base::Unretained(wrapped_), bound_cb));
		}

		@@ -215,7 +211,7 @@ class MediaInterfaceWrapper : public MediaInterface {

		auto bound_cb = base::Bind(cb_lambda, now_playing_cb);

		do_in_avrcp_jni(base::Bind(&MediaInterface::GetNowPlayingList,
		do_in_jni_thread(base::Bind(&MediaInterface::GetNowPlayingList,
		base::Unretained(wrapped_), bound_cb));
		}

		@@ -228,7 +224,7 @@ class MediaInterfaceWrapper : public MediaInterface {

		auto bound_cb = base::Bind(cb_lambda, list_cb);

		do_in_avrcp_jni(base::Bind(&MediaInterface::GetMediaPlayerList,
		do_in_jni_thread(base::Bind(&MediaInterface::GetMediaPlayerList,
		base::Unretained(wrapped_), bound_cb));
		}

		@@ -241,7 +237,7 @@ class MediaInterfaceWrapper : public MediaInterface {

		auto bound_cb = base::Bind(cb_lambda, folder_cb);

		do_in_avrcp_jni(base::Bind(&MediaInterface::GetFolderItems,
		do_in_jni_thread(base::Bind(&MediaInterface::GetFolderItems,
		base::Unretained(wrapped_), player_id, media_id,
		bound_cb));
		}
		@@ -256,20 +252,20 @@ class MediaInterfaceWrapper : public MediaInterface {

		auto bound_cb = base::Bind(cb_lambda, browse_cb);

		do_in_avrcp_jni(base::Bind(&MediaInterface::SetBrowsedPlayer,
		do_in_jni_thread(base::Bind(&MediaInterface::SetBrowsedPlayer,
		base::Unretained(wrapped_), player_id,
		bound_cb));
		}

		void PlayItem(uint16_t player_id, bool now_playing,
		std::string media_id) override {
		do_in_avrcp_jni(base::Bind(&MediaInterface::PlayItem,
		do_in_jni_thread(base::Bind(&MediaInterface::PlayItem,
		base::Unretained(wrapped_), player_id,
		now_playing, media_id));
		}

		void SetActiveDevice(const RawAddress& address) override {
		do_in_avrcp_jni(base::Bind(&MediaInterface::SetActiveDevice,
		do_in_jni_thread(base::Bind(&MediaInterface::SetActiveDevice,
		base::Unretained(wrapped_), address));
		}

		@@ -292,7 +288,7 @@ class VolumeInterfaceWrapper : public VolumeInterface {
		VolumeInterfaceWrapper(VolumeInterface* interface) : wrapped_(interface){};

		void DeviceConnected(const RawAddress& bdaddr) override {
		do_in_avrcp_jni(
		do_in_jni_thread(
		base::Bind(static_cast<void (VolumeInterface::*)(const RawAddress&)>(
		&VolumeInterface::DeviceConnected),
		base::Unretained(wrapped_), bdaddr));
		@@ -305,19 +301,19 @@ class VolumeInterfaceWrapper : public VolumeInterface {

		auto bound_cb = base::Bind(cb_lambda, cb);

		do_in_avrcp_jni(base::Bind(static_cast<void (VolumeInterface::*)(
		do_in_jni_thread(base::Bind(static_cast<void (VolumeInterface::*)(
		const RawAddress&, VolumeChangedCb)>(
		&VolumeInterface::DeviceConnected),
		base::Unretained(wrapped_), bdaddr, bound_cb));
		}

		void DeviceDisconnected(const RawAddress& bdaddr) override {
		do_in_avrcp_jni(base::Bind(&VolumeInterface::DeviceDisconnected,
		do_in_jni_thread(base::Bind(&VolumeInterface::DeviceDisconnected,
		base::Unretained(wrapped_), bdaddr));
		}

		void SetVolume(int8_t volume) override {
		do_in_avrcp_jni(base::Bind(&VolumeInterface::SetVolume,
		do_in_jni_thread(base::Bind(&VolumeInterface::SetVolume,
		base::Unretained(wrapped_), volume));
		}

		@@ -340,7 +336,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface {

		auto bound_cb = base::Bind(cb_lambda, cb);

		do_in_avrcp_jni(base::Bind(&PlayerSettingsInterface::ListPlayerSettings,
		do_in_jni_thread(base::Bind(&PlayerSettingsInterface::ListPlayerSettings,
		base::Unretained(wrapped_), bound_cb));
		}

		@@ -354,7 +350,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface {

		auto bound_cb = base::Bind(cb_lambda, cb);

		do_in_avrcp_jni(
		do_in_jni_thread(
		base::Bind(&PlayerSettingsInterface::ListPlayerSettingValues,
		base::Unretained(wrapped_), setting, bound_cb));
		}
		@@ -371,7 +367,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface {

		auto bound_cb = base::Bind(cb_lambda, cb);

		do_in_avrcp_jni(base::Bind(
		do_in_jni_thread(base::Bind(
		&PlayerSettingsInterface::GetCurrentPlayerSettingValue,
		base::Unretained(wrapped_), std::move(attributes), bound_cb));
		}
		@@ -385,7 +381,7 @@ class PlayerSettingsInterfaceWrapper : public PlayerSettingsInterface {

		auto bound_cb = base::Bind(cb_lambda, cb);

		do_in_avrcp_jni(base::Bind(
		do_in_jni_thread(base::Bind(
		&PlayerSettingsInterface::SetPlayerSettings, base::Unretained(wrapped_),
		std::move(attributes), std::move(values), bound_cb));
		}

system/btif/include/btif_common.h

+4 −9

Original line number	Diff line number	Diff line
		@@ -99,8 +99,6 @@ typedef struct {
		******************************************************************************/

		bt_status_t do_in_jni_thread(base::OnceClosure task);
		bt_status_t do_in_jni_thread(const base::Location& from_here,
		base::OnceClosure task);
		bool is_on_jni_thread();

		using BtJniClosure = std::function<void()>;
		@@ -111,15 +109,12 @@ void post_on_bt_jni(BtJniClosure closure);
		* thread
		*/
		template <typename R, typename... Args>
		base::Callback<R(Args...)> jni_thread_wrapper(const base::Location& from_here,
		base::Callback<R(Args...)> cb) {
		base::Callback<R(Args...)> jni_thread_wrapper(base::Callback<R(Args...)> cb) {
		return base::Bind(
		[](const base::Location& from_here, base::Callback<R(Args...)> cb,
		Args... args) {
		do_in_jni_thread(from_here,
		base::BindOnce(cb, std::forward<Args>(args)...));
		[](base::Callback<R(Args...)> cb, Args... args) {
		do_in_jni_thread(base::BindOnce(cb, std::forward<Args>(args)...));
		},
		from_here, std::move(cb));
		std::move(cb));
		}

		tBTA_SERVICE_MASK btif_get_enabled_services_mask(void);

system/btif/include/btif_jni_task.h

+0 −3

Original line number	Diff line number	Diff line
		@@ -48,9 +48,6 @@ bt_status_t btif_transfer_context(tBTIF_CBACK* p_cback, uint16_t event,
		* This function posts a task into the btif message loop, that executes it in
		* the JNI message loop.
		**/
		bt_status_t do_in_jni_thread(const base::Location& from_here,
		base::OnceClosure task);

		bt_status_t do_in_jni_thread(base::OnceClosure task);

		bool is_on_jni_thread();

system/btif/src/bluetooth.cc

+130 −163

Original line number	Diff line number	Diff line
		@@ -743,9 +743,7 @@ static int disconnect_all_acls() {

		static void le_rand_btif_cb(uint64_t random_number) {
		log::verbose("");
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](uint64_t random) { HAL_CBACK(bt_hal_cbacks, le_rand_cb, random); },
		random_number));
		}
		@@ -989,17 +987,13 @@ int le_test_mode(uint16_t opcode, uint8_t* buf, uint8_t len) {
		static bt_os_callouts_t* wakelock_os_callouts_saved = nullptr;

		static int acquire_wake_lock_cb(const char* lock_name) {
		return do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		return do_in_jni_thread(base::BindOnce(
		base::IgnoreResult(wakelock_os_callouts_saved->acquire_wake_lock),
		lock_name));
		}

		static int release_wake_lock_cb(const char* lock_name) {
		return do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		return do_in_jni_thread(base::BindOnce(
		base::IgnoreResult(wakelock_os_callouts_saved->release_wake_lock),
		lock_name));
		}
		@@ -1265,22 +1259,19 @@ bt_property_t* property_deep_copy_array(int num_properties,
		}

		void invoke_adapter_state_changed_cb(bt_state_t state) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bt_state_t state) {
		HAL_CBACK(bt_hal_cbacks,
		adapter_state_changed_cb, state);
		HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, state);
		},
		state));
		}

		void invoke_adapter_properties_cb(bt_status_t status, int num_properties,
		bt_property_t* properties) {
		do_in_jni_thread(FROM_HERE,
		base::BindOnce(
		[](bt_status_t status, int num_properties,
		bt_property_t* properties) {
		HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status,
		num_properties, properties);
		do_in_jni_thread(base::BindOnce(
		[](bt_status_t status, int num_properties, bt_property_t* properties) {
		HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, num_properties,
		properties);
		if (properties) {
		osi_free(properties);
		}
		@@ -1292,12 +1283,11 @@ void invoke_adapter_properties_cb(bt_status_t status, int num_properties,
		void invoke_remote_device_properties_cb(bt_status_t status, RawAddress bd_addr,
		int num_properties,
		bt_property_t* properties) {
		do_in_jni_thread(
		FROM_HERE, base::BindOnce(
		[](bt_status_t status, RawAddress bd_addr,
		int num_properties, bt_property_t* properties) {
		HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
		status, &bd_addr, num_properties, properties);
		do_in_jni_thread(base::BindOnce(
		[](bt_status_t status, RawAddress bd_addr, int num_properties,
		bt_property_t* properties) {
		HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, status, &bd_addr,
		num_properties, properties);
		if (properties) {
		osi_free(properties);
		}
		@@ -1307,36 +1297,30 @@ void invoke_remote_device_properties_cb(bt_status_t status, RawAddress bd_addr,
		}

		void invoke_device_found_cb(int num_properties, bt_property_t* properties) {
		do_in_jni_thread(FROM_HERE,
		base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](int num_properties, bt_property_t* properties) {
		HAL_CBACK(bt_hal_cbacks, device_found_cb,
		num_properties, properties);
		HAL_CBACK(bt_hal_cbacks, device_found_cb, num_properties, properties);
		if (properties) {
		osi_free(properties);
		}
		},
		num_properties,
		property_deep_copy_array(num_properties, properties)));
		num_properties, property_deep_copy_array(num_properties, properties)));
		}

		void invoke_discovery_state_changed_cb(bt_discovery_state_t state) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bt_discovery_state_t state) {
		HAL_CBACK(bt_hal_cbacks,
		discovery_state_changed_cb,
		state);
		HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb, state);
		},
		state));
		}

		void invoke_pin_request_cb(RawAddress bd_addr, bt_bdname_t bd_name,
		uint32_t cod, bool min_16_digit) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		[](RawAddress bd_addr, bt_bdname_t bd_name,
		uint32_t cod, bool min_16_digit) {
		HAL_CBACK(bt_hal_cbacks, pin_request_cb,
		&bd_addr, &bd_name, cod,
		do_in_jni_thread(base::BindOnce(
		[](RawAddress bd_addr, bt_bdname_t bd_name, uint32_t cod,
		bool min_16_digit) {
		HAL_CBACK(bt_hal_cbacks, pin_request_cb, &bd_addr, &bd_name, cod,
		min_16_digit);
		},
		bd_addr, bd_name, cod, min_16_digit));
		@@ -1344,12 +1328,11 @@ void invoke_pin_request_cb(RawAddress bd_addr, bt_bdname_t bd_name,

		void invoke_ssp_request_cb(RawAddress bd_addr, bt_ssp_variant_t pairing_variant,
		uint32_t pass_key) {
		do_in_jni_thread(FROM_HERE,
		base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](RawAddress bd_addr, bt_ssp_variant_t pairing_variant,
		uint32_t pass_key) {
		HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr,
		pairing_variant, pass_key);
		HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, pairing_variant,
		pass_key);
		},
		bd_addr, pairing_variant, pass_key));
		}
		@@ -1390,11 +1373,9 @@ void invoke_oob_data_request_cb(tBT_TRANSPORT t, bool valid, Octet16 c,
		// of itself. 16 + 16 + 2 = 34 Data 0x0022 Little Endian order 0x2200
		oob_data.oob_data_length[0] = 0;
		oob_data.oob_data_length[1] = 34;
		bt_status_t status = do_in_jni_thread(
		FROM_HERE, base::BindOnce(
		bt_status_t status = do_in_jni_thread(base::BindOnce(
		[](tBT_TRANSPORT t, bt_oob_data_t oob_data) {
		HAL_CBACK(bt_hal_cbacks, generate_local_oob_data_cb, t,
		oob_data);
		HAL_CBACK(bt_hal_cbacks, generate_local_oob_data_cb, t, oob_data);
		},
		t, oob_data));
		if (status != BT_STATUS_SUCCESS) {
		@@ -1404,34 +1385,31 @@ void invoke_oob_data_request_cb(tBT_TRANSPORT t, bool valid, Octet16 c,

		void invoke_bond_state_changed_cb(bt_status_t status, RawAddress bd_addr,
		bt_bond_state_t state, int fail_reason) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		[](bt_status_t status, RawAddress bd_addr,
		bt_bond_state_t state, int fail_reason) {
		HAL_CBACK(bt_hal_cbacks,
		bond_state_changed_cb, status,
		&bd_addr, state, fail_reason);
		do_in_jni_thread(base::BindOnce(
		[](bt_status_t status, RawAddress bd_addr, bt_bond_state_t state,
		int fail_reason) {
		HAL_CBACK(bt_hal_cbacks, bond_state_changed_cb, status, &bd_addr, state,
		fail_reason);
		},
		status, bd_addr, state, fail_reason));
		}

		void invoke_address_consolidate_cb(RawAddress main_bd_addr,
		RawAddress secondary_bd_addr) {
		do_in_jni_thread(
		FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](RawAddress main_bd_addr, RawAddress secondary_bd_addr) {
		HAL_CBACK(bt_hal_cbacks, address_consolidate_cb,
		&main_bd_addr, &secondary_bd_addr);
		HAL_CBACK(bt_hal_cbacks, address_consolidate_cb, &main_bd_addr,
		&secondary_bd_addr);
		},
		main_bd_addr, secondary_bd_addr));
		}

		void invoke_le_address_associate_cb(RawAddress main_bd_addr,
		RawAddress secondary_bd_addr) {
		do_in_jni_thread(
		FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](RawAddress main_bd_addr, RawAddress secondary_bd_addr) {
		HAL_CBACK(bt_hal_cbacks, le_address_associate_cb,
		&main_bd_addr, &secondary_bd_addr);
		HAL_CBACK(bt_hal_cbacks, le_address_associate_cb, &main_bd_addr,
		&secondary_bd_addr);
		},
		main_bd_addr, secondary_bd_addr));
		}
		@@ -1440,25 +1418,21 @@ void invoke_acl_state_changed_cb(bt_status_t status, RawAddress bd_addr,
		bt_hci_error_code_t hci_reason,
		bt_conn_direction_t direction,
		uint16_t acl_handle) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bt_status_t status, RawAddress bd_addr, bt_acl_state_t state,
		int transport_link_type, bt_hci_error_code_t hci_reason,
		bt_conn_direction_t direction, uint16_t acl_handle) {
		HAL_CBACK(bt_hal_cbacks, acl_state_changed_cb, status, &bd_addr,
		state, transport_link_type, hci_reason, direction,
		acl_handle);
		HAL_CBACK(bt_hal_cbacks, acl_state_changed_cb, status, &bd_addr, state,
		transport_link_type, hci_reason, direction, acl_handle);
		},
		status, bd_addr, state, transport_link_type, hci_reason, direction,
		acl_handle));
		}

		void invoke_thread_evt_cb(bt_cb_thread_evt event) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bt_cb_thread_evt event) {
		HAL_CBACK(bt_hal_cbacks, thread_evt_cb,
		event);
		HAL_CBACK(bt_hal_cbacks, thread_evt_cb, event);
		if (event == DISASSOCIATE_JVM) {
		bt_hal_cbacks = NULL;
		}
		@@ -1467,10 +1441,9 @@ void invoke_thread_evt_cb(bt_cb_thread_evt event) {
		}

		void invoke_le_test_mode_cb(bt_status_t status, uint16_t count) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bt_status_t status, uint16_t count) {
		HAL_CBACK(bt_hal_cbacks, le_test_mode_cb,
		status, count);
		HAL_CBACK(bt_hal_cbacks, le_test_mode_cb, status, count);
		},
		status, count));
		}
		@@ -1478,9 +1451,7 @@ void invoke_le_test_mode_cb(bt_status_t status, uint16_t count) {
		// takes ownership of \|uid_data\|
		void invoke_energy_info_cb(bt_activity_energy_info energy_info,
		bt_uid_traffic_t* uid_data) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bt_activity_energy_info energy_info, bt_uid_traffic_t* uid_data) {
		HAL_CBACK(bt_hal_cbacks, energy_info_cb, &energy_info, uid_data);
		osi_free(uid_data);
		@@ -1493,7 +1464,6 @@ void invoke_link_quality_report_cb(uint64_t timestamp, int report_id, int rssi,
		int packets_not_receive_count,
		int negative_acknowledgement_count) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		[](uint64_t timestamp, int report_id, int rssi, int snr,
		int retransmission_count, int packets_not_receive_count,
		@@ -1508,29 +1478,26 @@ void invoke_link_quality_report_cb(uint64_t timestamp, int report_id, int rssi,
		}

		void invoke_switch_buffer_size_cb(bool is_low_latency_buffer_size) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bool is_low_latency_buffer_size) {
		HAL_CBACK(bt_hal_cbacks,
		switch_buffer_size_cb,
		HAL_CBACK(bt_hal_cbacks, switch_buffer_size_cb,
		is_low_latency_buffer_size);
		},
		is_low_latency_buffer_size));
		}

		void invoke_switch_codec_cb(bool is_low_latency_buffer_size) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](bool is_low_latency_buffer_size) {
		HAL_CBACK(bt_hal_cbacks, switch_codec_cb,
		is_low_latency_buffer_size);
		HAL_CBACK(bt_hal_cbacks, switch_codec_cb, is_low_latency_buffer_size);
		},
		is_low_latency_buffer_size));
		}

		void invoke_key_missing_cb(RawAddress bd_addr) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		[](RawAddress bd_addr) {
		HAL_CBACK(bt_hal_cbacks, key_missing_cb,
		bd_addr);
		HAL_CBACK(bt_hal_cbacks, key_missing_cb, bd_addr);
		},
		bd_addr));
		}

system/btif/src/btif_av.cc

+16 −29

Original line number	Diff line number	Diff line
		@@ -2942,12 +2942,10 @@ static void btif_report_connection_state(const RawAddress& peer_address,

		if (peer->IsSink()) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(btif_av_source.Callbacks()->connection_state_cb,
		peer_address, state, btav_error_t{}));
		} else if (peer->IsSource()) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(btif_av_sink.Callbacks()->connection_state_cb,
		peer_address, state, btav_error_t{}));
		}
		@@ -2955,15 +2953,11 @@ static void btif_report_connection_state(const RawAddress& peer_address,
		}

		if (btif_av_source.Enabled()) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		btif_av_source.Callbacks()->connection_state_cb, peer_address,
		state, btav_error_t{.status = status, .error_code = error_code}));
		do_in_jni_thread(base::BindOnce(
		btif_av_source.Callbacks()->connection_state_cb, peer_address, state,
		btav_error_t{.status = status, .error_code = error_code}));
		} else if (btif_av_sink.Enabled()) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(
		do_in_jni_thread(base::BindOnce(
		btif_av_sink.Callbacks()->connection_state_cb, peer_address, state,
		btav_error_t{.status = status, .error_code = error_code}));
		}
		@@ -2986,23 +2980,19 @@ static void btif_report_audio_state(const RawAddress& peer_address,
		if (btif_av_both_enable()) {
		BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
		if (peer->IsSink()) {
		do_in_jni_thread(
		FROM_HERE, base::BindOnce(btif_av_source.Callbacks()->audio_state_cb,
		peer_address, state));
		do_in_jni_thread(base::BindOnce(
		btif_av_source.Callbacks()->audio_state_cb, peer_address, state));
		} else if (peer->IsSource()) {
		do_in_jni_thread(FROM_HERE,
		base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,
		do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,
		peer_address, state));
		}
		return;
		}
		if (btif_av_source.Enabled()) {
		do_in_jni_thread(FROM_HERE,
		base::BindOnce(btif_av_source.Callbacks()->audio_state_cb,
		do_in_jni_thread(base::BindOnce(btif_av_source.Callbacks()->audio_state_cb,
		peer_address, state));
		} else if (btif_av_sink.Enabled()) {
		do_in_jni_thread(FROM_HERE,
		base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,
		do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb,
		peer_address, state));
		}

		@@ -3035,11 +3025,9 @@ void btif_av_report_source_codec_state(
		codecs_selectable_capabilities) {
		log::verbose("peer={}", peer_address);
		if (btif_av_source.Enabled()) {
		do_in_jni_thread(
		FROM_HERE,
		base::BindOnce(btif_av_source.Callbacks()->audio_config_cb,
		peer_address, codec_config, codecs_local_capabilities,
		codecs_selectable_capabilities));
		do_in_jni_thread(base::BindOnce(
		btif_av_source.Callbacks()->audio_config_cb, peer_address, codec_config,
		codecs_local_capabilities, codecs_selectable_capabilities));
		}
		}

		@@ -3055,8 +3043,7 @@ static void btif_av_report_sink_audio_config_state(
		log::info("peer={} sample_rate={} channel_count={}", peer_address,
		sample_rate, channel_count);
		if (btif_av_sink.Enabled()) {
		do_in_jni_thread(FROM_HERE,
		base::BindOnce(btif_av_sink.Callbacks()->audio_config_cb,
		do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_config_cb,
		peer_address, sample_rate, channel_count));
		}
		}
		@@ -3091,7 +3078,7 @@ static void btif_av_query_mandatory_codec_priority(
		}
		};
		if (btif_av_source.Enabled()) {
		do_in_jni_thread(FROM_HERE, base::BindOnce(query_priority, peer_address));
		do_in_jni_thread(base::BindOnce(query_priority, peer_address));
		}
		}