Merge "system: Convert DVLOG() instances" into main (d2fad73b) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/gatt/bta_gattc_cache.cc

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -350,8 +350,6 @@ void bta_gattc_start_disc_char_dscp(uint16_t conn_id,

	descriptor_discovery_done:		descriptor_discovery_done:
	/* all characteristic has been explored, start with next service if any */		/* all characteristic has been explored, start with next service if any */
	DVLOG(3) << "all characteristics explored";

	bta_gattc_explore_next_service(conn_id, p_srvc_cb);		bta_gattc_explore_next_service(conn_id, p_srvc_cb);
	return;		return;
	}		}

system/btif/src/btif_csis_client.cc

+15 −31

Original line number	Original line	Diff line number	Diff line
	@@ -47,7 +47,6 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
	~CsipSetCoordinatorServiceInterfaceImpl() override = default;		~CsipSetCoordinatorServiceInterfaceImpl() override = default;

	void Init(CsisClientCallbacks* callbacks) override {		void Init(CsisClientCallbacks* callbacks) override {
	DVLOG(2) << __func__;
	this->callbacks_ = callbacks;		this->callbacks_ = callbacks;

	do_in_main_thread(		do_in_main_thread(
	@@ -63,33 +62,31 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,

	void Connect(const RawAddress& addr) override {		void Connect(const RawAddress& addr) override {
	if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {		if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	}		}

	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);
	do_in_main_thread(FROM_HERE, Bind(&CsisClient::Connect,		do_in_main_thread(FROM_HERE, Bind(&CsisClient::Connect,
	Unretained(CsisClient::Get()), addr));		Unretained(CsisClient::Get()), addr));
	}		}

	void Disconnect(const RawAddress& addr) override {		void Disconnect(const RawAddress& addr) override {
	if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {		if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	}		}

	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);
	do_in_main_thread(FROM_HERE, Bind(&CsisClient::Disconnect,		do_in_main_thread(FROM_HERE, Bind(&CsisClient::Disconnect,
	Unretained(CsisClient::Get()), addr));		Unretained(CsisClient::Get()), addr));
	}		}

	void RemoveDevice(const RawAddress& addr) override {		void RemoveDevice(const RawAddress& addr) override {
	if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {		if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not ready";		"service being not ready";

	@@ -98,7 +95,6 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
	return;		return;
	}		}

	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);
	do_in_main_thread(FROM_HERE, Bind(&CsisClient::RemoveDevice,		do_in_main_thread(FROM_HERE, Bind(&CsisClient::RemoveDevice,
	Unretained(CsisClient::Get()), addr));		Unretained(CsisClient::Get()), addr));
	/* Clear storage */		/* Clear storage */
	@@ -107,13 +103,12 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,

	void LockGroup(int group_id, bool lock) override {		void LockGroup(int group_id, bool lock) override {
	if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {		if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	}		}

	DVLOG(2) << __func__ << " group id: " << group_id << " lock: " << lock;
	do_in_main_thread(		do_in_main_thread(
	FROM_HERE, Bind(&CsisClient::LockGroup, Unretained(CsisClient::Get()),		FROM_HERE, Bind(&CsisClient::LockGroup, Unretained(CsisClient::Get()),
	group_id, lock, base::DoNothing()));		group_id, lock, base::DoNothing()));
	@@ -121,38 +116,30 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,

	void Cleanup(void) override {		void Cleanup(void) override {
	if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {		if (!initialized \|\| !CsisClient::IsCsisClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	}		}

	DVLOG(2) << __func__;
	initialized = false;		initialized = false;
	do_in_main_thread(FROM_HERE, Bind(&CsisClient::CleanUp));		do_in_main_thread(FROM_HERE, Bind(&CsisClient::CleanUp));
	}		}

	void OnConnectionState(const RawAddress& addr,		void OnConnectionState(const RawAddress& addr,
	ConnectionState state) override {		ConnectionState state) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);
	do_in_jni_thread(FROM_HERE, Bind(&CsisClientCallbacks::OnConnectionState,		do_in_jni_thread(FROM_HERE, Bind(&CsisClientCallbacks::OnConnectionState,
	Unretained(callbacks_), addr, state));		Unretained(callbacks_), addr, state));
	}		}

	void OnDeviceAvailable(const RawAddress& addr, int group_id, int group_size,		void OnDeviceAvailable(const RawAddress& addr, int group_id, int group_size,
	int rank, const bluetooth::Uuid& uuid) override {		int rank, const bluetooth::Uuid& uuid) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr)
	<< " group_id: " << group_id;

	do_in_jni_thread(FROM_HERE, Bind(&CsisClientCallbacks::OnDeviceAvailable,		do_in_jni_thread(FROM_HERE, Bind(&CsisClientCallbacks::OnDeviceAvailable,
	Unretained(callbacks_), addr, group_id,		Unretained(callbacks_), addr, group_id,
	group_size, rank, uuid));		group_size, rank, uuid));
	}		}

	void OnSetMemberAvailable(const RawAddress& addr, int group_id) override {		void OnSetMemberAvailable(const RawAddress& addr, int group_id) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr)
	<< " group id: " << group_id;

	do_in_jni_thread(FROM_HERE, Bind(&CsisClientCallbacks::OnSetMemberAvailable,		do_in_jni_thread(FROM_HERE, Bind(&CsisClientCallbacks::OnSetMemberAvailable,
	Unretained(callbacks_), addr, group_id));		Unretained(callbacks_), addr, group_id));
	}		}
	@@ -160,9 +147,6 @@ class CsipSetCoordinatorServiceInterfaceImpl : public CsisClientInterface,
	/* Callback for lock changed in the group */		/* Callback for lock changed in the group */
	virtual void OnGroupLockChanged(int group_id, bool locked,		virtual void OnGroupLockChanged(int group_id, bool locked,
	CsisGroupLockStatus status) override {		CsisGroupLockStatus status) override {
	DVLOG(2) << __func__ << " group id: " << group_id << " lock: " << locked
	<< " status: " << int(status);

	do_in_jni_thread(FROM_HERE,		do_in_jni_thread(FROM_HERE,
	Bind(&CsisClientCallbacks::OnGroupLockChanged,		Bind(&CsisClientCallbacks::OnGroupLockChanged,
	Unretained(callbacks_), group_id, locked, status));		Unretained(callbacks_), group_id, locked, status));

system/btif/src/btif_has_client.cc

+0 −45

Original line number	Original line	Diff line number	Diff line
	@@ -51,7 +51,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
	~HearingAaccessClientServiceInterfaceImpl() override = default;		~HearingAaccessClientServiceInterfaceImpl() override = default;

	void Init(HasClientCallbacks* callbacks) override {		void Init(HasClientCallbacks* callbacks) override {
	DVLOG(2) << __func__;
	this->callbacks_ = callbacks;		this->callbacks_ = callbacks;

	do_in_main_thread(		do_in_main_thread(
	@@ -63,7 +62,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
	}		}

	void Connect(const RawAddress& addr) override {		void Connect(const RawAddress& addr) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);
	do_in_main_thread(FROM_HERE, Bind(&HasClient::Connect,		do_in_main_thread(FROM_HERE, Bind(&HasClient::Connect,
	Unretained(HasClient::Get()), addr));		Unretained(HasClient::Get()), addr));

	@@ -72,7 +70,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
	}		}

	void Disconnect(const RawAddress& addr) override {		void Disconnect(const RawAddress& addr) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);
	do_in_main_thread(FROM_HERE, Bind(&HasClient::Disconnect,		do_in_main_thread(FROM_HERE, Bind(&HasClient::Disconnect,
	Unretained(HasClient::Get()), addr));		Unretained(HasClient::Get()), addr));

	@@ -82,8 +79,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,

	void SelectActivePreset(std::variant<RawAddress, int> addr_or_group_id,		void SelectActivePreset(std::variant<RawAddress, int> addr_or_group_id,
	uint8_t preset_index) override {		uint8_t preset_index) override {
	DVLOG(2) << __func__ << " preset_index: " << preset_index;

	do_in_main_thread(		do_in_main_thread(
	FROM_HERE,		FROM_HERE,
	Bind(&HasClient::SelectActivePreset, Unretained(HasClient::Get()),		Bind(&HasClient::SelectActivePreset, Unretained(HasClient::Get()),
	@@ -92,8 +87,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,

	void NextActivePreset(		void NextActivePreset(
	std::variant<RawAddress, int> addr_or_group_id) override {		std::variant<RawAddress, int> addr_or_group_id) override {
	DVLOG(2) << __func__;

	do_in_main_thread(FROM_HERE, Bind(&HasClient::NextActivePreset,		do_in_main_thread(FROM_HERE, Bind(&HasClient::NextActivePreset,
	Unretained(HasClient::Get()),		Unretained(HasClient::Get()),
	std::move(addr_or_group_id)));		std::move(addr_or_group_id)));
	@@ -101,17 +94,12 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,

	void PreviousActivePreset(		void PreviousActivePreset(
	std::variant<RawAddress, int> addr_or_group_id) override {		std::variant<RawAddress, int> addr_or_group_id) override {
	DVLOG(2) << __func__;

	do_in_main_thread(FROM_HERE, Bind(&HasClient::PreviousActivePreset,		do_in_main_thread(FROM_HERE, Bind(&HasClient::PreviousActivePreset,
	Unretained(HasClient::Get()),		Unretained(HasClient::Get()),
	std::move(addr_or_group_id)));		std::move(addr_or_group_id)));
	}		}

	void GetPresetInfo(const RawAddress& addr, uint8_t preset_index) override {		void GetPresetInfo(const RawAddress& addr, uint8_t preset_index) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr)
	<< " preset_index: " << preset_index;

	do_in_main_thread(		do_in_main_thread(
	FROM_HERE, Bind(&HasClient::GetPresetInfo, Unretained(HasClient::Get()),		FROM_HERE, Bind(&HasClient::GetPresetInfo, Unretained(HasClient::Get()),
	addr, preset_index));		addr, preset_index));
	@@ -119,9 +107,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,

	void SetPresetName(std::variant<RawAddress, int> addr_or_group_id,		void SetPresetName(std::variant<RawAddress, int> addr_or_group_id,
	uint8_t preset_index, std::string preset_name) override {		uint8_t preset_index, std::string preset_name) override {
	DVLOG(2) << __func__ << " preset_index: " << preset_index
	<< " preset_name: " << preset_name;

	do_in_main_thread(		do_in_main_thread(
	FROM_HERE, Bind(&HasClient::SetPresetName, Unretained(HasClient::Get()),		FROM_HERE, Bind(&HasClient::SetPresetName, Unretained(HasClient::Get()),
	std::move(addr_or_group_id), preset_index,		std::move(addr_or_group_id), preset_index,
	@@ -129,8 +114,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
	}		}

	void RemoveDevice(const RawAddress& addr) override {		void RemoveDevice(const RawAddress& addr) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);

	/* RemoveDevice can be called on devices that don't have BAS enabled */		/* RemoveDevice can be called on devices that don't have BAS enabled */
	if (HasClient::IsHasClientRunning()) {		if (HasClient::IsHasClientRunning()) {
	do_in_main_thread(FROM_HERE, Bind(&HasClient::Disconnect,		do_in_main_thread(FROM_HERE, Bind(&HasClient::Disconnect,
	@@ -141,37 +124,27 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
	}		}

	void Cleanup(void) override {		void Cleanup(void) override {
	DVLOG(2) << __func__;
	do_in_main_thread(FROM_HERE, Bind(&HasClient::CleanUp));		do_in_main_thread(FROM_HERE, Bind(&HasClient::CleanUp));
	}		}

	void OnConnectionState(ConnectionState state,		void OnConnectionState(ConnectionState state,
	const RawAddress& addr) override {		const RawAddress& addr) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr);
	do_in_jni_thread(FROM_HERE, Bind(&HasClientCallbacks::OnConnectionState,		do_in_jni_thread(FROM_HERE, Bind(&HasClientCallbacks::OnConnectionState,
	Unretained(callbacks_), state, addr));		Unretained(callbacks_), state, addr));
	}		}

	void OnDeviceAvailable(const RawAddress& addr, uint8_t features) override {		void OnDeviceAvailable(const RawAddress& addr, uint8_t features) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr)
	<< " features: " << features;

	do_in_jni_thread(FROM_HERE, Bind(&HasClientCallbacks::OnDeviceAvailable,		do_in_jni_thread(FROM_HERE, Bind(&HasClientCallbacks::OnDeviceAvailable,
	Unretained(callbacks_), addr, features));		Unretained(callbacks_), addr, features));
	}		}

	void OnFeaturesUpdate(const RawAddress& addr, uint8_t features) override {		void OnFeaturesUpdate(const RawAddress& addr, uint8_t features) override {
	DVLOG(2) << __func__ << " addr: " << ADDRESS_TO_LOGGABLE_STR(addr)
	<< " ha_features: " << std::bitset<8>(features);

	do_in_jni_thread(FROM_HERE, Bind(&HasClientCallbacks::OnFeaturesUpdate,		do_in_jni_thread(FROM_HERE, Bind(&HasClientCallbacks::OnFeaturesUpdate,
	Unretained(callbacks_), addr, features));		Unretained(callbacks_), addr, features));
	}		}

	void OnActivePresetSelected(std::variant<RawAddress, int> addr_or_group_id,		void OnActivePresetSelected(std::variant<RawAddress, int> addr_or_group_id,
	uint8_t preset_index) override {		uint8_t preset_index) override {
	DVLOG(2) << __func__ << " preset_index: " << preset_index;

	do_in_jni_thread(FROM_HERE,		do_in_jni_thread(FROM_HERE,
	Bind(&HasClientCallbacks::OnActivePresetSelected,		Bind(&HasClientCallbacks::OnActivePresetSelected,
	Unretained(callbacks_), std::move(addr_or_group_id),		Unretained(callbacks_), std::move(addr_or_group_id),
	@@ -180,9 +153,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,

	void OnActivePresetSelectError(std::variant<RawAddress, int> addr_or_group_id,		void OnActivePresetSelectError(std::variant<RawAddress, int> addr_or_group_id,
	ErrorCode result_code) override {		ErrorCode result_code) override {
	DVLOG(2) << __func__ << " result_code: "
	<< static_cast<std::underlying_type<ErrorCode>::type>(result_code);

	do_in_jni_thread(		do_in_jni_thread(
	FROM_HERE,		FROM_HERE,
	Bind(&HasClientCallbacks::OnActivePresetSelectError,		Bind(&HasClientCallbacks::OnActivePresetSelectError,
	@@ -192,15 +162,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
	void OnPresetInfo(std::variant<RawAddress, int> addr_or_group_id,		void OnPresetInfo(std::variant<RawAddress, int> addr_or_group_id,
	PresetInfoReason change_id,		PresetInfoReason change_id,
	std::vector<PresetInfo> detail_records) override {		std::vector<PresetInfo> detail_records) override {
	DVLOG(2) << __func__;
	for (const auto& rec : detail_records) {
	DVLOG(2) << "\t index: " << +rec.preset_index << ", change_id: "
	<< (std::underlying_type<PresetInfoReason>::type)change_id
	<< ", writable: " << rec.writable
	<< ", available: " << rec.available
	<< ", name: " << rec.preset_name;
	}

	do_in_jni_thread(FROM_HERE,		do_in_jni_thread(FROM_HERE,
	Bind(&HasClientCallbacks::OnPresetInfo,		Bind(&HasClientCallbacks::OnPresetInfo,
	Unretained(callbacks_), std::move(addr_or_group_id),		Unretained(callbacks_), std::move(addr_or_group_id),
	@@ -209,9 +170,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,

	void OnPresetInfoError(std::variant<RawAddress, int> addr_or_group_id,		void OnPresetInfoError(std::variant<RawAddress, int> addr_or_group_id,
	uint8_t preset_index, ErrorCode result_code) override {		uint8_t preset_index, ErrorCode result_code) override {
	DVLOG(2) << __func__ << " result_code: "
	<< static_cast<std::underlying_type<ErrorCode>::type>(result_code);

	do_in_jni_thread(		do_in_jni_thread(
	FROM_HERE,		FROM_HERE,
	Bind(&HasClientCallbacks::OnPresetInfoError, Unretained(callbacks_),		Bind(&HasClientCallbacks::OnPresetInfoError, Unretained(callbacks_),
	@@ -221,9 +179,6 @@ class HearingAaccessClientServiceInterfaceImpl : public HasClientInterface,
	void OnSetPresetNameError(std::variant<RawAddress, int> addr_or_group_id,		void OnSetPresetNameError(std::variant<RawAddress, int> addr_or_group_id,
	uint8_t preset_index,		uint8_t preset_index,
	ErrorCode result_code) override {		ErrorCode result_code) override {
	DVLOG(2) << __func__ << " result_code: "
	<< static_cast<std::underlying_type<ErrorCode>::type>(result_code);

	do_in_jni_thread(		do_in_jni_thread(
	FROM_HERE,		FROM_HERE,
	Bind(&HasClientCallbacks::OnSetPresetNameError, Unretained(callbacks_),		Bind(&HasClientCallbacks::OnSetPresetNameError, Unretained(callbacks_),

system/btif/src/btif_hearing_aid.cc

+0 −12

Original line number	Original line	Diff line number	Diff line
	@@ -57,7 +57,6 @@ class HearingAidInterfaceImpl
	~HearingAidInterfaceImpl() override = default;		~HearingAidInterfaceImpl() override = default;

	void Init(HearingAidCallbacks* callbacks) override {		void Init(HearingAidCallbacks* callbacks) override {
	DVLOG(2) << __func__;
	this->callbacks = callbacks;		this->callbacks = callbacks;
	do_in_main_thread(		do_in_main_thread(
	FROM_HERE,		FROM_HERE,
	@@ -68,48 +67,38 @@ class HearingAidInterfaceImpl

	void OnConnectionState(ConnectionState state,		void OnConnectionState(ConnectionState state,
	const RawAddress& address) override {		const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);
	do_in_jni_thread(FROM_HERE, Bind(&HearingAidCallbacks::OnConnectionState,		do_in_jni_thread(FROM_HERE, Bind(&HearingAidCallbacks::OnConnectionState,
	Unretained(callbacks), state, address));		Unretained(callbacks), state, address));
	}		}

	void OnDeviceAvailable(uint8_t capabilities, uint64_t hiSyncId,		void OnDeviceAvailable(uint8_t capabilities, uint64_t hiSyncId,
	const RawAddress& address) override {		const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address)
	<< ", hiSyncId: " << loghex(hiSyncId)
	<< ", capabilities: " << loghex(capabilities);
	do_in_jni_thread(FROM_HERE, Bind(&HearingAidCallbacks::OnDeviceAvailable,		do_in_jni_thread(FROM_HERE, Bind(&HearingAidCallbacks::OnDeviceAvailable,
	Unretained(callbacks), capabilities,		Unretained(callbacks), capabilities,
	hiSyncId, address));		hiSyncId, address));
	}		}

	void Connect(const RawAddress& address) override {		void Connect(const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);
	do_in_main_thread(FROM_HERE, Bind(&HearingAid::Connect, address));		do_in_main_thread(FROM_HERE, Bind(&HearingAid::Connect, address));
	}		}

	void Disconnect(const RawAddress& address) override {		void Disconnect(const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);
	do_in_main_thread(FROM_HERE, Bind(&HearingAid::Disconnect, address));		do_in_main_thread(FROM_HERE, Bind(&HearingAid::Disconnect, address));
	do_in_jni_thread(FROM_HERE, Bind(&btif_storage_set_hearing_aid_acceptlist,		do_in_jni_thread(FROM_HERE, Bind(&btif_storage_set_hearing_aid_acceptlist,
	address, false));		address, false));
	}		}

	void AddToAcceptlist(const RawAddress& address) override {		void AddToAcceptlist(const RawAddress& address) override {
	VLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);
	do_in_main_thread(FROM_HERE, Bind(&HearingAid::AddToAcceptlist, address));		do_in_main_thread(FROM_HERE, Bind(&HearingAid::AddToAcceptlist, address));
	do_in_jni_thread(FROM_HERE, Bind(&btif_storage_set_hearing_aid_acceptlist,		do_in_jni_thread(FROM_HERE, Bind(&btif_storage_set_hearing_aid_acceptlist,
	address, true));		address, true));
	}		}

	void SetVolume(int8_t volume) override {		void SetVolume(int8_t volume) override {
	DVLOG(2) << __func__ << " volume: " << +volume;
	do_in_main_thread(FROM_HERE, Bind(&HearingAid::SetVolume, volume));		do_in_main_thread(FROM_HERE, Bind(&HearingAid::SetVolume, volume));
	}		}

	void RemoveDevice(const RawAddress& address) override {		void RemoveDevice(const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);

	// RemoveDevice can be called on devices that don't have HA enabled		// RemoveDevice can be called on devices that don't have HA enabled
	if (HearingAid::IsHearingAidRunning()) {		if (HearingAid::IsHearingAidRunning()) {
	do_in_main_thread(FROM_HERE, Bind(&HearingAid::Disconnect, address));		do_in_main_thread(FROM_HERE, Bind(&HearingAid::Disconnect, address));
	@@ -120,7 +109,6 @@ class HearingAidInterfaceImpl
	}		}

	void Cleanup(void) override {		void Cleanup(void) override {
	DVLOG(2) << __func__;
	do_in_main_thread(FROM_HERE, Bind(&HearingAid::CleanUp));		do_in_main_thread(FROM_HERE, Bind(&HearingAid::CleanUp));
	}		}

system/btif/src/btif_le_audio.cc

+36 −60

Original line number	Original line	Diff line number	Diff line
	@@ -149,9 +149,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void Cleanup(void) override {		void Cleanup(void) override {
	DVLOG(2) << __func__;
	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -163,10 +162,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void RemoveDevice(const RawAddress& address) override {		void RemoveDevice(const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);

	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";

	@@ -182,10 +179,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void Connect(const RawAddress& address) override {		void Connect(const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);

	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -197,10 +192,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void Disconnect(const RawAddress& address) override {		void Disconnect(const RawAddress& address) override {
	DVLOG(2) << __func__ << " address: " << ADDRESS_TO_LOGGABLE_STR(address);

	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -212,10 +205,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void SetEnableState(const RawAddress& address, bool enabled) override {		void SetEnableState(const RawAddress& address, bool enabled) override {
	DVLOG(2) << __func__ << " address: " << address << ", enabled: " << enabled;

	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -227,11 +218,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void GroupAddNode(const int group_id, const RawAddress& address) override {		void GroupAddNode(const int group_id, const RawAddress& address) override {
	DVLOG(2) << __func__ << " group_id: " << group_id
	<< " address: " << ADDRESS_TO_LOGGABLE_STR(address);

	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -243,10 +231,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void GroupRemoveNode(const int group_id, const RawAddress& address) override {		void GroupRemoveNode(const int group_id, const RawAddress& address) override {
	DVLOG(2) << __func__ << " group_id: " << group_id
	<< " address: " << ADDRESS_TO_LOGGABLE_STR(address);
	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -258,9 +244,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void GroupSetActive(const int group_id) override {		void GroupSetActive(const int group_id) override {
	DVLOG(2) << __func__ << " group_id: " << group_id;
	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -274,9 +259,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	void SetCodecConfigPreference(int group_id,		void SetCodecConfigPreference(int group_id,
	btle_audio_codec_config_t input_codec_config,		btle_audio_codec_config_t input_codec_config,
	btle_audio_codec_config_t output_codec_config) {		btle_audio_codec_config_t output_codec_config) {
	DVLOG(2) << __func__ << " group_id: " << group_id;
	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -288,10 +272,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void SetCcidInformation(int ccid, int context_type) {		void SetCcidInformation(int ccid, int context_type) {
	DVLOG(2) << __func__ << " ccid: " << ccid << " context_type"
	<< context_type;
	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -303,9 +285,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	}		}

	void SetInCall(bool in_call) {		void SetInCall(bool in_call) {
	DVLOG(2) << __func__ << " in_call: " << in_call;
	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;
	@@ -319,13 +300,8 @@ class LeAudioClientInterfaceImpl : public LeAudioClientInterface,
	void SendAudioProfilePreferences(int group_id,		void SendAudioProfilePreferences(int group_id,
	bool is_output_preference_le_audio,		bool is_output_preference_le_audio,
	bool is_duplex_preference_le_audio) {		bool is_duplex_preference_le_audio) {
	DVLOG(2) << __func__ << " group_id: " << group_id
	<< ", is_output_preference_le_audio: "
	<< is_output_preference_le_audio
	<< ", is_duplex_preference_le_audio: "
	<< is_duplex_preference_le_audio;
	if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {		if (!initialized \|\| !LeAudioClient::IsLeAudioClientRunning()) {
	DVLOG(2) << __func__		VLOG(1) << __func__
	<< " call ignored, due to already started cleanup procedure or "		<< " call ignored, due to already started cleanup procedure or "
	"service being not read";		"service being not read";
	return;		return;