Merge "Revert "Add an explicit TWT register events call"" into main (9b851739) · Commits · e / os / android_hardware_interfaces

wifi/aidl/default/wifi_legacy_hal.cpp

+5 −9

Original line number	Diff line number	Diff line
		@@ -1867,8 +1867,9 @@ std::pair<wifi_twt_capabilities, wifi_error> WifiLegacyHal::twtGetCapabilities(
		return {capabs, status};
		}

		wifi_error WifiLegacyHal::twtRegisterEvents(
		const std::string& ifaceName, const on_twt_failure& on_twt_failure_user_callback,
		wifi_error WifiLegacyHal::twtSessionSetup(
		const std::string& ifaceName, uint32_t cmdId, const wifi_twt_request& request,
		const on_twt_failure& on_twt_failure_user_callback,
		const on_twt_session_create& on_twt_session_create_user_callback,
		const on_twt_session_update& on_twt_session_update_user_callback,
		const on_twt_session_teardown& on_twt_session_teardown_user_callback,
		@@ -1920,18 +1921,13 @@ wifi_error WifiLegacyHal::twtRegisterEvents(
		on_twt_session_resume_user_callback(id, session_id);
		};

		return global_func_table_.wifi_twt_register_events(
		getIfaceHandle(ifaceName),
		return global_func_table_.wifi_twt_session_setup(
		cmdId, getIfaceHandle(ifaceName), request,
		{onAsyncTwtError, onAsyncTwtSessionCreate, onAsyncTwtSessionUpdate,
		onAsyncTwtSessionTeardown, onAsyncTwtSessionStats, onAsyncTwtSessionSuspend,
		onAsyncTwtSessionResume});
		}

		wifi_error WifiLegacyHal::twtSessionSetup(const std::string& ifaceName, uint32_t cmdId,
		const wifi_twt_request& request) {
		return global_func_table_.wifi_twt_session_setup(cmdId, getIfaceHandle(ifaceName), request);
		}

		wifi_error WifiLegacyHal::twtSessionUpdate(const std::string& ifaceName, uint32_t cmdId,
		uint32_t sessionId, const wifi_twt_request& request) {
		return global_func_table_.wifi_twt_session_update(cmdId, getIfaceHandle(ifaceName), sessionId,

wifi/aidl/default/wifi_legacy_hal.h

+9 −10

Original line number	Diff line number	Diff line
		@@ -780,16 +780,15 @@ class WifiLegacyHal {

		// TWT functions
		std::pair<wifi_twt_capabilities, wifi_error> twtGetCapabilities(const std::string& ifaceName);
		wifi_error twtRegisterEvents(
		const std::string& ifaceName, const on_twt_failure& on_twt_failure_user_callback,
		wifi_error twtSessionSetup(const std::string& ifaceName, uint32_t cmdId,
		const wifi_twt_request& request,
		const on_twt_failure& on_twt_failure_user_callback,
		const on_twt_session_create& on_twt_session_create_user_callback,
		const on_twt_session_update& on_twt_session_update_user_callback,
		const on_twt_session_teardown& on_twt_session_teardown_user_callback,
		const on_twt_session_stats& on_twt_session_stats_user_callback,
		const on_twt_session_suspend& on_twt_session_suspend_user_callback,
		const on_twt_session_resume& on_twt_session_resume_user_callback);
		wifi_error twtSessionSetup(const std::string& ifaceName, uint32_t cmdId,
		const wifi_twt_request& request);
		wifi_error twtSessionUpdate(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId,
		const wifi_twt_request& request);
		wifi_error twtSessionSuspend(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId);
		@@ -798,7 +797,7 @@ class WifiLegacyHal {
		wifi_error twtSessionGetStats(const std::string& ifaceName, uint32_t cmdId, uint32_t sessionId);

		// Note: Following TWT functions are deprecated
		// Deprecated by twtRegisterEvegnts
		// Deprecated
		wifi_error twtRegisterHandler(const std::string& iface_name,
		const TwtCallbackHandlers& handler);
		// Deprecated by twtGetCapabilities

wifi/aidl/default/wifi_legacy_hal_stubs.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -182,7 +182,6 @@ bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn) {
		populateStubFor(&hal_fn->wifi_get_rtt_capabilities_v3);
		populateStubFor(&hal_fn->wifi_rtt_range_request_v3);
		populateStubFor(&hal_fn->wifi_twt_get_capabilities);
		populateStubFor(&hal_fn->wifi_twt_register_events);
		populateStubFor(&hal_fn->wifi_twt_session_setup);
		populateStubFor(&hal_fn->wifi_twt_session_update);
		populateStubFor(&hal_fn->wifi_twt_session_suspend);

wifi/aidl/default/wifi_sta_iface.cpp

+129 −150

Original line number	Diff line number	Diff line
		@@ -31,11 +31,7 @@ using aidl_return_util::validateAndCall;
		WifiStaIface::WifiStaIface(const std::string& ifname,
		const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
		const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
		: ifname_(ifname),
		legacy_hal_(legacy_hal),
		iface_util_(iface_util),
		is_valid_(true),
		is_twt_registered_(false) {
		: ifname_(ifname), legacy_hal_(legacy_hal), iface_util_(iface_util), is_valid_(true) {
		// Turn on DFS channel usage for STA iface.
		legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setDfsFlag(ifname_, true);
		if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		@@ -270,150 +266,11 @@ std::pair<std::string, ndk::ScopedAStatus> WifiStaIface::getNameInternal() {
		return {ifname_, ndk::ScopedAStatus::ok()};
		}

		ndk::ScopedAStatus WifiStaIface::registerTwtEventCallbackInternal() {
		std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_;

		// onTwtFailure callback
		const auto& on_twt_failure = [weak_ptr_this](legacy_hal::wifi_request_id id,
		legacy_hal::wifi_twt_error_code error_code) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		IWifiStaIfaceEventCallback::TwtErrorCode aidl_error_code =
		aidl_struct_util::convertLegacyHalTwtErrorCodeToAidl(error_code);
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtFailure(id, aidl_error_code).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtFailure callback";
		}
		}
		};
		// onTwtSessionCreate callback
		const auto& on_twt_session_create = [weak_ptr_this](legacy_hal::wifi_request_id id,
		legacy_hal::wifi_twt_session twt_session) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		TwtSession aidl_twt_session;
		if (!aidl_struct_util::convertLegacyHalTwtSessionToAidl(twt_session, &aidl_twt_session)) {
		LOG(ERROR) << "convertLegacyHalTwtSessionToAidl failed";
		return;
		}

		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionCreate(id, aidl_twt_session).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionCreate callback";
		}
		}
		};
		// onTwtSessionUpdate callback
		const auto& on_twt_session_update = [weak_ptr_this](legacy_hal::wifi_request_id id,
		legacy_hal::wifi_twt_session twt_session) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		TwtSession aidl_twt_session;
		if (!aidl_struct_util::convertLegacyHalTwtSessionToAidl(twt_session, &aidl_twt_session)) {
		LOG(ERROR) << "convertLegacyHalTwtSessionToAidl failed";
		return;
		}

		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionUpdate(id, aidl_twt_session).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionUpdate callback";
		}
		}
		};
		// onTwtSessionTeardown callback
		const auto& on_twt_session_teardown =
		[weak_ptr_this](legacy_hal::wifi_request_id id, int session_id,
		legacy_hal::wifi_twt_teardown_reason_code reason_code) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		IWifiStaIfaceEventCallback::TwtTeardownReasonCode aidl_reason_code =
		aidl_struct_util::convertLegacyHalTwtReasonCodeToAidl(reason_code);
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionTeardown(id, session_id, aidl_reason_code).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionTeardown callback";
		}
		}
		};
		// onTwtSessionStats callback
		const auto& on_twt_session_stats = [weak_ptr_this](legacy_hal::wifi_request_id id,
		int session_id,
		legacy_hal::wifi_twt_session_stats stats) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		TwtSessionStats aidl_session_stats;
		if (!aidl_struct_util::convertLegacyHalTwtSessionStatsToAidl(stats, &aidl_session_stats)) {
		LOG(ERROR) << "convertLegacyHalTwtSessionStatsToAidl failed";
		return;
		}
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionStats(id, session_id, aidl_session_stats).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionStats callback";
		}
		}
		};
		// onTwtSessionSuspend callback
		const auto& on_twt_session_suspend = [weak_ptr_this](legacy_hal::wifi_request_id id,
		int session_id) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionSuspend(id, session_id).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionSuspend callback";
		}
		}
		};
		// onTwtSessionResume callback
		const auto& on_twt_session_resume = [weak_ptr_this](legacy_hal::wifi_request_id id,
		int session_id) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionResume(id, session_id).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionResume callback";
		}
		}
		};

		legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->twtRegisterEvents(
		ifname_, on_twt_failure, on_twt_session_create, on_twt_session_update,
		on_twt_session_teardown, on_twt_session_stats, on_twt_session_suspend,
		on_twt_session_resume);

		if (legacy_status == legacy_hal::WIFI_ERROR_NOT_SUPPORTED) {
		LOG(INFO) << "twtRegisterEvents is not supported" << legacy_status;
		} else if (legacy_status != legacy_hal::WIFI_SUCCESS) {
		LOG(ERROR) << "twtRegisterEvents failed - %d" << legacy_status;
		}
		return createWifiStatusFromLegacyError(legacy_status);
		}

		ndk::ScopedAStatus WifiStaIface::registerEventCallbackInternal(
		const std::shared_ptr<IWifiStaIfaceEventCallback>& callback) {
		if (!event_cb_handler_.addCallback(callback)) {
		return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
		}
		is_twt_registered_ = registerTwtEventCallbackInternal().isOk();
		return ndk::ScopedAStatus::ok();
		}

		@@ -760,16 +617,138 @@ std::pair<TwtCapabilities, ndk::ScopedAStatus> WifiStaIface::twtGetCapabilitiesI

		ndk::ScopedAStatus WifiStaIface::twtSessionSetupInternal(int32_t cmdId,
		const TwtRequest& aidlTwtRequest) {
		if (!is_twt_registered_) {
		LOG(INFO) << "twtSessionSetup is not supported as twtRegisterEvents failed";
		return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
		}
		legacy_hal::wifi_twt_request legacyHalTwtRequest;
		if (!aidl_struct_util::convertAidlTwtRequestToLegacy(aidlTwtRequest, &legacyHalTwtRequest)) {
		return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
		}
		legacy_hal::wifi_error legacy_status =
		legacy_hal_.lock()->twtSessionSetup(ifname_, cmdId, legacyHalTwtRequest);
		std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_;

		// onTwtFailure callback
		const auto& on_twt_failure = [weak_ptr_this](legacy_hal::wifi_request_id id,
		legacy_hal::wifi_twt_error_code error_code) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		IWifiStaIfaceEventCallback::TwtErrorCode aidl_error_code =
		aidl_struct_util::convertLegacyHalTwtErrorCodeToAidl(error_code);
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtFailure(id, aidl_error_code).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtFailure callback";
		}
		}
		};
		// onTwtSessionCreate callback
		const auto& on_twt_session_create = [weak_ptr_this](legacy_hal::wifi_request_id id,
		legacy_hal::wifi_twt_session twt_session) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		TwtSession aidl_twt_session;
		if (!aidl_struct_util::convertLegacyHalTwtSessionToAidl(twt_session, &aidl_twt_session)) {
		LOG(ERROR) << "convertLegacyHalTwtSessionToAidl failed";
		return;
		}

		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionCreate(id, aidl_twt_session).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionCreate callback";
		}
		}
		};
		// onTwtSessionUpdate callback
		const auto& on_twt_session_update = [weak_ptr_this](legacy_hal::wifi_request_id id,
		legacy_hal::wifi_twt_session twt_session) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		TwtSession aidl_twt_session;
		if (!aidl_struct_util::convertLegacyHalTwtSessionToAidl(twt_session, &aidl_twt_session)) {
		LOG(ERROR) << "convertLegacyHalTwtSessionToAidl failed";
		return;
		}

		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionUpdate(id, aidl_twt_session).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionUpdate callback";
		}
		}
		};
		// onTwtSessionTeardown callback
		const auto& on_twt_session_teardown =
		[weak_ptr_this](legacy_hal::wifi_request_id id, int session_id,
		legacy_hal::wifi_twt_teardown_reason_code reason_code) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		IWifiStaIfaceEventCallback::TwtTeardownReasonCode aidl_reason_code =
		aidl_struct_util::convertLegacyHalTwtReasonCodeToAidl(reason_code);
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionTeardown(id, session_id, aidl_reason_code).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionTeardown callback";
		}
		}
		};
		// onTwtSessionStats callback
		const auto& on_twt_session_stats = [weak_ptr_this](legacy_hal::wifi_request_id id,
		int session_id,
		legacy_hal::wifi_twt_session_stats stats) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		TwtSessionStats aidl_session_stats;
		if (!aidl_struct_util::convertLegacyHalTwtSessionStatsToAidl(stats, &aidl_session_stats)) {
		LOG(ERROR) << "convertLegacyHalTwtSessionStatsToAidl failed";
		return;
		}
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionStats(id, session_id, aidl_session_stats).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionStats callback";
		}
		}
		};
		// onTwtSessionSuspend callback
		const auto& on_twt_session_suspend = [weak_ptr_this](legacy_hal::wifi_request_id id,
		int session_id) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionSuspend(id, session_id).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionSuspend callback";
		}
		}
		};
		// onTwtSessionResume callback
		const auto& on_twt_session_resume = [weak_ptr_this](legacy_hal::wifi_request_id id,
		int session_id) {
		const auto shared_ptr_this = weak_ptr_this.lock();
		if (!shared_ptr_this.get() \|\| !shared_ptr_this->isValid()) {
		LOG(ERROR) << "Callback invoked on an invalid object";
		return;
		}
		for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
		if (!callback->onTwtSessionResume(id, session_id).isOk()) {
		LOG(ERROR) << "Failed to invoke onTwtSessionResume callback";
		}
		}
		};

		legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->twtSessionSetup(
		ifname_, cmdId, legacyHalTwtRequest, on_twt_failure, on_twt_session_create,
		on_twt_session_update, on_twt_session_teardown, on_twt_session_stats,
		on_twt_session_suspend, on_twt_session_resume);
		return createWifiStatusFromLegacyError(legacy_status);
		}

wifi/aidl/default/wifi_sta_iface.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -103,7 +103,6 @@ class WifiStaIface : public BnWifiStaIface {
		private:
		// Corresponding worker functions for the AIDL methods.
		std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
		ndk::ScopedAStatus registerTwtEventCallbackInternal();
		ndk::ScopedAStatus registerEventCallbackInternal(
		const std::shared_ptr<IWifiStaIfaceEventCallback>& callback);
		std::pair<int32_t, ndk::ScopedAStatus> getFeatureSetInternal();
		@@ -158,7 +157,6 @@ class WifiStaIface : public BnWifiStaIface {
		std::weak_ptr<WifiStaIface> weak_ptr_this_;
		bool is_valid_;
		aidl_callback_util::AidlCallbackHandler<IWifiStaIfaceEventCallback> event_cb_handler_;
		bool is_twt_registered_;

		DISALLOW_COPY_AND_ASSIGN(WifiStaIface);
		};