| /* |
| * Copyright (C) 2022 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "wifi_sta_iface.h" |
| |
| #include <android-base/logging.h> |
| |
| #include "aidl_return_util.h" |
| #include "aidl_struct_util.h" |
| #include "wifi_status_util.h" |
| |
| namespace aidl { |
| namespace android { |
| namespace hardware { |
| namespace wifi { |
| 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) { |
| // 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) { |
| LOG(ERROR) << "Failed to set DFS flag; DFS channels may be unavailable."; |
| } |
| } |
| |
| std::shared_ptr<WifiStaIface> WifiStaIface::create( |
| const std::string& ifname, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal, |
| const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) { |
| std::shared_ptr<WifiStaIface> ptr = |
| ndk::SharedRefBase::make<WifiStaIface>(ifname, legacy_hal, iface_util); |
| std::weak_ptr<WifiStaIface> weak_ptr_this(ptr); |
| ptr->setWeakPtr(weak_ptr_this); |
| return ptr; |
| } |
| |
| void WifiStaIface::invalidate() { |
| legacy_hal_.reset(); |
| event_cb_handler_.invalidate(); |
| is_valid_ = false; |
| } |
| |
| void WifiStaIface::setWeakPtr(std::weak_ptr<WifiStaIface> ptr) { |
| weak_ptr_this_ = ptr; |
| } |
| |
| bool WifiStaIface::isValid() { |
| return is_valid_; |
| } |
| |
| std::string WifiStaIface::getName() { |
| return ifname_; |
| } |
| |
| std::set<std::shared_ptr<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() { |
| return event_cb_handler_.getCallbacks(); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getName(std::string* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getNameInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::registerEventCallback( |
| const std::shared_ptr<IWifiStaIfaceEventCallback>& in_callback) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::registerEventCallbackInternal, in_callback); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getFeatureSet(int32_t* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getFeatureSetInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getApfPacketFilterCapabilities( |
| StaApfPacketFilterCapabilities* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getApfPacketFilterCapabilitiesInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::installApfPacketFilter(const std::vector<uint8_t>& in_program) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::installApfPacketFilterInternal, in_program); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::readApfPacketFilterData(std::vector<uint8_t>* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::readApfPacketFilterDataInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getBackgroundScanCapabilities( |
| StaBackgroundScanCapabilities* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getBackgroundScanCapabilitiesInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startBackgroundScan(int32_t in_cmdId, |
| const StaBackgroundScanParameters& in_params) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startBackgroundScanInternal, in_cmdId, in_params); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::stopBackgroundScan(int32_t in_cmdId) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::stopBackgroundScanInternal, in_cmdId); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::enableLinkLayerStatsCollection(bool in_debug) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::enableLinkLayerStatsCollectionInternal, in_debug); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::disableLinkLayerStatsCollection() { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::disableLinkLayerStatsCollectionInternal); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getLinkLayerStats(StaLinkLayerStats* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getLinkLayerStatsInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startRssiMonitoring(int32_t in_cmdId, int32_t in_maxRssi, |
| int32_t in_minRssi) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startRssiMonitoringInternal, in_cmdId, in_maxRssi, |
| in_minRssi); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::stopRssiMonitoring(int32_t in_cmdId) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::stopRssiMonitoringInternal, in_cmdId); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getRoamingCapabilities(StaRoamingCapabilities* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getRoamingCapabilitiesInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::configureRoaming(const StaRoamingConfig& in_config) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::configureRoamingInternal, in_config); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setRoamingState(StaRoamingState in_state) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::setRoamingStateInternal, in_state); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::enableNdOffload(bool in_enable) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::enableNdOffloadInternal, in_enable); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startSendingKeepAlivePackets( |
| int32_t in_cmdId, const std::vector<uint8_t>& in_ipPacketData, char16_t in_etherType, |
| const std::array<uint8_t, 6>& in_srcAddress, const std::array<uint8_t, 6>& in_dstAddress, |
| int32_t in_periodInMs) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startSendingKeepAlivePacketsInternal, in_cmdId, |
| in_ipPacketData, in_etherType, in_srcAddress, in_dstAddress, |
| in_periodInMs); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::stopSendingKeepAlivePackets(int32_t in_cmdId) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::stopSendingKeepAlivePacketsInternal, in_cmdId); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startDebugPacketFateMonitoring() { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startDebugPacketFateMonitoringInternal); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getDebugTxPacketFates( |
| std::vector<WifiDebugTxPacketFateReport>* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getDebugTxPacketFatesInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getDebugRxPacketFates( |
| std::vector<WifiDebugRxPacketFateReport>* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getDebugRxPacketFatesInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setMacAddress(const std::array<uint8_t, 6>& in_mac) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::setMacAddressInternal, in_mac); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getFactoryMacAddressInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setScanMode(bool in_enable) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::setScanModeInternal, in_enable); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setDtimMultiplier(int32_t in_multiplier) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::setDtimMultiplierInternal, in_multiplier); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::getCachedScanData(CachedScanData* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getCachedScanDataInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtGetCapabilities(TwtCapabilities* _aidl_return) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::twtGetCapabilitiesInternal, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionSetup(int32_t in_cmdId, |
| const TwtRequest& in_twtRequest) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::twtSessionSetupInternal, in_cmdId, in_twtRequest); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionUpdate(int32_t in_cmdId, int32_t in_sessionId, |
| const TwtRequest& in_twtRequest) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::twtSessionUpdateInternal, in_cmdId, in_sessionId, |
| in_twtRequest); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionSuspend(int32_t in_cmdId, int32_t in_sessionId) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::twtSessionSuspendInternal, in_cmdId, in_sessionId); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionResume(int32_t in_cmdId, int32_t in_sessionId) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::twtSessionResumeInternal, in_cmdId, in_sessionId); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionTeardown(int32_t in_cmdId, int32_t in_sessionId) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::twtSessionTeardownInternal, in_cmdId, in_sessionId); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionGetStats(int32_t in_cmdId, int32_t in_sessionId) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::twtSessionGetStatsInternal, in_cmdId, in_sessionId); |
| } |
| |
| 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(); |
| } |
| |
| std::pair<int32_t, ndk::ScopedAStatus> WifiStaIface::getFeatureSetInternal() { |
| legacy_hal::wifi_error legacy_status; |
| uint64_t legacy_feature_set; |
| std::tie(legacy_status, legacy_feature_set) = |
| legacy_hal_.lock()->getSupportedFeatureSet(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {0, createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| uint32_t aidl_feature_set; |
| if (!aidl_struct_util::convertLegacyStaIfaceFeaturesToAidl(legacy_feature_set, |
| &aidl_feature_set)) { |
| return {0, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| return {aidl_feature_set, ndk::ScopedAStatus::ok()}; |
| } |
| |
| std::pair<StaApfPacketFilterCapabilities, ndk::ScopedAStatus> |
| WifiStaIface::getApfPacketFilterCapabilitiesInternal() { |
| legacy_hal::wifi_error legacy_status; |
| legacy_hal::PacketFilterCapabilities legacy_caps; |
| std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getPacketFilterCapabilities(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {StaApfPacketFilterCapabilities{}, createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| StaApfPacketFilterCapabilities aidl_caps; |
| if (!aidl_struct_util::convertLegacyApfCapabilitiesToAidl(legacy_caps, &aidl_caps)) { |
| return {StaApfPacketFilterCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| return {aidl_caps, ndk::ScopedAStatus::ok()}; |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::installApfPacketFilterInternal( |
| const std::vector<uint8_t>& program) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setPacketFilter(ifname_, program); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> |
| WifiStaIface::readApfPacketFilterDataInternal() { |
| const std::pair<legacy_hal::wifi_error, std::vector<uint8_t>> legacy_status_and_data = |
| legacy_hal_.lock()->readApfPacketFilterData(ifname_); |
| return {std::move(legacy_status_and_data.second), |
| createWifiStatusFromLegacyError(legacy_status_and_data.first)}; |
| } |
| |
| std::pair<StaBackgroundScanCapabilities, ndk::ScopedAStatus> |
| WifiStaIface::getBackgroundScanCapabilitiesInternal() { |
| legacy_hal::wifi_error legacy_status; |
| legacy_hal::wifi_gscan_capabilities legacy_caps; |
| std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getGscanCapabilities(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {StaBackgroundScanCapabilities{}, createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| StaBackgroundScanCapabilities aidl_caps; |
| if (!aidl_struct_util::convertLegacyGscanCapabilitiesToAidl(legacy_caps, &aidl_caps)) { |
| return {StaBackgroundScanCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| return {aidl_caps, ndk::ScopedAStatus::ok()}; |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startBackgroundScanInternal( |
| int32_t cmd_id, const StaBackgroundScanParameters& params) { |
| legacy_hal::wifi_scan_cmd_params legacy_params; |
| if (!aidl_struct_util::convertAidlGscanParamsToLegacy(params, &legacy_params)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_; |
| const auto& on_failure_callback = [weak_ptr_this](legacy_hal::wifi_request_id 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->onBackgroundScanFailure(id).isOk()) { |
| LOG(ERROR) << "Failed to invoke onBackgroundScanFailure callback"; |
| } |
| } |
| }; |
| const auto& on_results_callback = |
| [weak_ptr_this](legacy_hal::wifi_request_id id, |
| const std::vector<legacy_hal::wifi_cached_scan_results>& results) { |
| 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; |
| } |
| std::vector<StaScanData> aidl_scan_datas; |
| if (!aidl_struct_util::convertLegacyVectorOfCachedGscanResultsToAidl( |
| results, &aidl_scan_datas)) { |
| LOG(ERROR) << "Failed to convert scan results to AIDL structs"; |
| return; |
| } |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->onBackgroundScanResults(id, aidl_scan_datas).isOk()) { |
| LOG(ERROR) << "Failed to invoke onBackgroundScanResults callback"; |
| } |
| } |
| }; |
| const auto& on_full_result_callback = [weak_ptr_this]( |
| legacy_hal::wifi_request_id id, |
| const legacy_hal::wifi_scan_result* result, |
| uint32_t buckets_scanned) { |
| 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; |
| } |
| StaScanResult aidl_scan_result; |
| if (!aidl_struct_util::convertLegacyGscanResultToAidl(*result, true, &aidl_scan_result)) { |
| LOG(ERROR) << "Failed to convert full scan results to AIDL structs"; |
| return; |
| } |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->onBackgroundFullScanResult(id, buckets_scanned, aidl_scan_result) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback"; |
| } |
| } |
| }; |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->startGscan(ifname_, cmd_id, legacy_params, on_failure_callback, |
| on_results_callback, on_full_result_callback); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::stopBackgroundScanInternal(int32_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopGscan(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableLinkLayerStats(ifname_, debug); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableLinkLayerStats(ifname_); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<StaLinkLayerStats, ndk::ScopedAStatus> WifiStaIface::getLinkLayerStatsInternal() { |
| legacy_hal::wifi_error legacy_status; |
| legacy_hal::LinkLayerStats legacy_stats{}; |
| legacy_hal::LinkLayerMlStats legacy_ml_stats{}; |
| legacy_status = legacy_hal_.lock()->getLinkLayerStats(ifname_, legacy_stats, legacy_ml_stats); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {StaLinkLayerStats{}, createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| StaLinkLayerStats aidl_stats; |
| if (legacy_stats.valid) { |
| if (!aidl_struct_util::convertLegacyLinkLayerStatsToAidl(legacy_stats, &aidl_stats)) { |
| return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| } else if (legacy_ml_stats.valid) { |
| if (!aidl_struct_util::convertLegacyLinkLayerMlStatsToAidl(legacy_ml_stats, &aidl_stats)) { |
| return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| } else { |
| return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| aidl_struct_util::logAidlLinkLayerStatsSize(aidl_stats); |
| return {aidl_stats, ndk::ScopedAStatus::ok()}; |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startRssiMonitoringInternal(int32_t cmd_id, int32_t max_rssi, |
| int32_t min_rssi) { |
| std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_; |
| const auto& on_threshold_breached_callback = |
| [weak_ptr_this](legacy_hal::wifi_request_id id, std::array<uint8_t, ETH_ALEN> bssid, |
| int8_t rssi) { |
| 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->onRssiThresholdBreached(id, bssid, rssi).isOk()) { |
| LOG(ERROR) << "Failed to invoke onRssiThresholdBreached callback"; |
| } |
| } |
| }; |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRssiMonitoring( |
| ifname_, cmd_id, max_rssi, min_rssi, on_threshold_breached_callback); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::stopRssiMonitoringInternal(int32_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopRssiMonitoring(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<StaRoamingCapabilities, ndk::ScopedAStatus> |
| WifiStaIface::getRoamingCapabilitiesInternal() { |
| legacy_hal::wifi_error legacy_status; |
| legacy_hal::wifi_roaming_capabilities legacy_caps; |
| std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRoamingCapabilities(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {StaRoamingCapabilities{}, createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| StaRoamingCapabilities aidl_caps; |
| if (!aidl_struct_util::convertLegacyRoamingCapabilitiesToAidl(legacy_caps, &aidl_caps)) { |
| return {StaRoamingCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| return {aidl_caps, ndk::ScopedAStatus::ok()}; |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::configureRoamingInternal(const StaRoamingConfig& config) { |
| legacy_hal::wifi_roaming_config legacy_config; |
| if (!aidl_struct_util::convertAidlRoamingConfigToLegacy(config, &legacy_config)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->configureRoaming(ifname_, legacy_config); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableFirmwareRoaming( |
| ifname_, aidl_struct_util::convertAidlRoamingStateToLegacy(state)); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::enableNdOffloadInternal(bool enable) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->configureNdOffload(ifname_, enable); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startSendingKeepAlivePacketsInternal( |
| int32_t cmd_id, const std::vector<uint8_t>& ip_packet_data, char16_t ether_type, |
| const std::array<uint8_t, 6>& src_address, const std::array<uint8_t, 6>& dst_address, |
| int32_t period_in_ms) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startSendingOffloadedPacket( |
| ifname_, cmd_id, ether_type, ip_packet_data, src_address, dst_address, period_in_ms); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(int32_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->stopSendingOffloadedPacket(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::startDebugPacketFateMonitoringInternal() { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startPktFateMonitoring(ifname_); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<std::vector<WifiDebugTxPacketFateReport>, ndk::ScopedAStatus> |
| WifiStaIface::getDebugTxPacketFatesInternal() { |
| legacy_hal::wifi_error legacy_status; |
| std::vector<legacy_hal::wifi_tx_report> legacy_fates; |
| std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getTxPktFates(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {std::vector<WifiDebugTxPacketFateReport>(), |
| createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| std::vector<WifiDebugTxPacketFateReport> aidl_fates; |
| if (!aidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToAidl(legacy_fates, |
| &aidl_fates)) { |
| return {std::vector<WifiDebugTxPacketFateReport>(), |
| createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| return {aidl_fates, ndk::ScopedAStatus::ok()}; |
| } |
| |
| std::pair<std::vector<WifiDebugRxPacketFateReport>, ndk::ScopedAStatus> |
| WifiStaIface::getDebugRxPacketFatesInternal() { |
| legacy_hal::wifi_error legacy_status; |
| std::vector<legacy_hal::wifi_rx_report> legacy_fates; |
| std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getRxPktFates(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {std::vector<WifiDebugRxPacketFateReport>(), |
| createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| std::vector<WifiDebugRxPacketFateReport> aidl_fates; |
| if (!aidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToAidl(legacy_fates, |
| &aidl_fates)) { |
| return {std::vector<WifiDebugRxPacketFateReport>(), |
| createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| return {aidl_fates, ndk::ScopedAStatus::ok()}; |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) { |
| bool status = iface_util_.lock()->setMacAddress(ifname_, mac); |
| if (!status) { |
| return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); |
| } |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> WifiStaIface::getFactoryMacAddressInternal() { |
| std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifname_); |
| if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) { |
| return {mac, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| return {mac, ndk::ScopedAStatus::ok()}; |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setScanModeInternal(bool enable) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setScanMode(ifname_, enable); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::setDtimMultiplierInternal(const int multiplier) { |
| legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setDtimConfig(ifname_, multiplier); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<CachedScanData, ndk::ScopedAStatus> WifiStaIface::getCachedScanDataInternal() { |
| legacy_hal::WifiCachedScanReport cached_scan_report; |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->getWifiCachedScanResults(ifname_, cached_scan_report); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {CachedScanData{}, createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| CachedScanData aidl_scan_data; |
| if (!aidl_struct_util::convertCachedScanReportToAidl(cached_scan_report, &aidl_scan_data)) { |
| return {CachedScanData{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)}; |
| } |
| |
| return {aidl_scan_data, ndk::ScopedAStatus::ok()}; |
| } |
| |
| std::pair<TwtCapabilities, ndk::ScopedAStatus> WifiStaIface::twtGetCapabilitiesInternal() { |
| legacy_hal::wifi_twt_capabilities legacyHaltwtCapabilities; |
| legacy_hal::wifi_error legacy_status; |
| std::tie(legacyHaltwtCapabilities, legacy_status) = |
| legacy_hal_.lock()->twtGetCapabilities(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {TwtCapabilities{}, createWifiStatusFromLegacyError(legacy_status)}; |
| } |
| TwtCapabilities aidlTwtCapabilities; |
| if (!aidl_struct_util::convertTwtCapabilitiesToAidl(legacyHaltwtCapabilities, |
| &aidlTwtCapabilities)) { |
| return {TwtCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)}; |
| } |
| return {aidlTwtCapabilities, ndk::ScopedAStatus::ok()}; |
| } |
| |
| 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); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionUpdateInternal(int32_t cmdId, int32_t sessionId, |
| const TwtRequest& aidlTwtRequest) { |
| 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()->twtSessionUpdate(ifname_, cmdId, sessionId, legacyHalTwtRequest); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionSuspendInternal(int32_t cmdId, int32_t sessionId) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->twtSessionSuspend(ifname_, cmdId, sessionId); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionResumeInternal(int32_t cmdId, int32_t sessionId) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->twtSessionResume(ifname_, cmdId, sessionId); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionTeardownInternal(int32_t cmdId, int32_t sessionId) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->twtSessionTeardown(ifname_, cmdId, sessionId); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| ndk::ScopedAStatus WifiStaIface::twtSessionGetStatsInternal(int32_t cmdId, int32_t sessionId) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->twtSessionGetStats(ifname_, cmdId, sessionId); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| } // namespace wifi |
| } // namespace hardware |
| } // namespace android |
| } // namespace aidl |