| /* |
| * Copyright (C) 2016 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 <android-base/logging.h> |
| |
| #include "hidl_return_util.h" |
| #include "hidl_struct_util.h" |
| #include "wifi_sta_iface.h" |
| #include "wifi_status_util.h" |
| |
| namespace android { |
| namespace hardware { |
| namespace wifi { |
| namespace V1_3 { |
| namespace implementation { |
| using hidl_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) { |
| // 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."; |
| } |
| } |
| |
| void WifiStaIface::invalidate() { |
| legacy_hal_.reset(); |
| event_cb_handler_.invalidate(); |
| is_valid_ = false; |
| } |
| |
| bool WifiStaIface::isValid() { return is_valid_; } |
| |
| std::string WifiStaIface::getName() { return ifname_; } |
| |
| std::set<sp<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() { |
| return event_cb_handler_.getCallbacks(); |
| } |
| |
| Return<void> WifiStaIface::getName(getName_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getNameInternal, hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getType(getType_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getTypeInternal, hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::registerEventCallback( |
| const sp<IWifiStaIfaceEventCallback>& callback, |
| registerEventCallback_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::registerEventCallbackInternal, |
| hidl_status_cb, callback); |
| } |
| |
| Return<void> WifiStaIface::getCapabilities(getCapabilities_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getCapabilitiesInternal, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getApfPacketFilterCapabilities( |
| getApfPacketFilterCapabilities_cb hidl_status_cb) { |
| return validateAndCall( |
| this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getApfPacketFilterCapabilitiesInternal, hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::installApfPacketFilter( |
| uint32_t cmd_id, const hidl_vec<uint8_t>& program, |
| installApfPacketFilter_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::installApfPacketFilterInternal, |
| hidl_status_cb, cmd_id, program); |
| } |
| |
| Return<void> WifiStaIface::readApfPacketFilterData( |
| readApfPacketFilterData_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::readApfPacketFilterDataInternal, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getBackgroundScanCapabilities( |
| getBackgroundScanCapabilities_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getBackgroundScanCapabilitiesInternal, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getValidFrequenciesForBand( |
| WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getValidFrequenciesForBandInternal, |
| hidl_status_cb, band); |
| } |
| |
| Return<void> WifiStaIface::startBackgroundScan( |
| uint32_t cmd_id, const StaBackgroundScanParameters& params, |
| startBackgroundScan_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startBackgroundScanInternal, |
| hidl_status_cb, cmd_id, params); |
| } |
| |
| Return<void> WifiStaIface::stopBackgroundScan( |
| uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::stopBackgroundScanInternal, |
| hidl_status_cb, cmd_id); |
| } |
| |
| Return<void> WifiStaIface::enableLinkLayerStatsCollection( |
| bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) { |
| return validateAndCall( |
| this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::enableLinkLayerStatsCollectionInternal, hidl_status_cb, |
| debug); |
| } |
| |
| Return<void> WifiStaIface::disableLinkLayerStatsCollection( |
| disableLinkLayerStatsCollection_cb hidl_status_cb) { |
| return validateAndCall( |
| this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::disableLinkLayerStatsCollectionInternal, hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getLinkLayerStats( |
| getLinkLayerStats_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getLinkLayerStatsInternal, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getLinkLayerStats_1_3( |
| getLinkLayerStats_1_3_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getLinkLayerStatsInternal_1_3, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::startRssiMonitoring( |
| uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi, |
| startRssiMonitoring_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startRssiMonitoringInternal, |
| hidl_status_cb, cmd_id, max_rssi, min_rssi); |
| } |
| |
| Return<void> WifiStaIface::stopRssiMonitoring( |
| uint32_t cmd_id, stopRssiMonitoring_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::stopRssiMonitoringInternal, |
| hidl_status_cb, cmd_id); |
| } |
| |
| Return<void> WifiStaIface::getRoamingCapabilities( |
| getRoamingCapabilities_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getRoamingCapabilitiesInternal, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::configureRoaming( |
| const StaRoamingConfig& config, configureRoaming_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::configureRoamingInternal, |
| hidl_status_cb, config); |
| } |
| |
| Return<void> WifiStaIface::setRoamingState(StaRoamingState state, |
| setRoamingState_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::setRoamingStateInternal, |
| hidl_status_cb, state); |
| } |
| |
| Return<void> WifiStaIface::enableNdOffload(bool enable, |
| enableNdOffload_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::enableNdOffloadInternal, |
| hidl_status_cb, enable); |
| } |
| |
| Return<void> WifiStaIface::startSendingKeepAlivePackets( |
| uint32_t cmd_id, const hidl_vec<uint8_t>& ip_packet_data, |
| uint16_t ether_type, const hidl_array<uint8_t, 6>& src_address, |
| const hidl_array<uint8_t, 6>& dst_address, uint32_t period_in_ms, |
| startSendingKeepAlivePackets_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startSendingKeepAlivePacketsInternal, |
| hidl_status_cb, cmd_id, ip_packet_data, ether_type, |
| src_address, dst_address, period_in_ms); |
| } |
| |
| Return<void> WifiStaIface::stopSendingKeepAlivePackets( |
| uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::stopSendingKeepAlivePacketsInternal, |
| hidl_status_cb, cmd_id); |
| } |
| |
| Return<void> WifiStaIface::setScanningMacOui( |
| const hidl_array<uint8_t, 3>& oui, setScanningMacOui_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::setScanningMacOuiInternal, |
| hidl_status_cb, oui); |
| } |
| |
| Return<void> WifiStaIface::startDebugPacketFateMonitoring( |
| startDebugPacketFateMonitoring_cb hidl_status_cb) { |
| return validateAndCall( |
| this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::startDebugPacketFateMonitoringInternal, hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getDebugTxPacketFates( |
| getDebugTxPacketFates_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getDebugTxPacketFatesInternal, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::getDebugRxPacketFates( |
| getDebugRxPacketFates_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getDebugRxPacketFatesInternal, |
| hidl_status_cb); |
| } |
| |
| Return<void> WifiStaIface::setMacAddress(const hidl_array<uint8_t, 6>& mac, |
| setMacAddress_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::setMacAddressInternal, hidl_status_cb, |
| mac); |
| } |
| |
| Return<void> WifiStaIface::getFactoryMacAddress( |
| getFactoryMacAddress_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiStaIface::getFactoryMacAddressInternal, |
| hidl_status_cb); |
| } |
| |
| std::pair<WifiStatus, std::string> WifiStaIface::getNameInternal() { |
| return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_}; |
| } |
| |
| std::pair<WifiStatus, IfaceType> WifiStaIface::getTypeInternal() { |
| return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::STA}; |
| } |
| |
| WifiStatus WifiStaIface::registerEventCallbackInternal( |
| const sp<IWifiStaIfaceEventCallback>& callback) { |
| if (!event_cb_handler_.addCallback(callback)) { |
| return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); |
| } |
| return createWifiStatus(WifiStatusCode::SUCCESS); |
| } |
| |
| std::pair<WifiStatus, uint32_t> WifiStaIface::getCapabilitiesInternal() { |
| legacy_hal::wifi_error legacy_status; |
| uint32_t legacy_feature_set; |
| std::tie(legacy_status, legacy_feature_set) = |
| legacy_hal_.lock()->getSupportedFeatureSet(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {createWifiStatusFromLegacyError(legacy_status), 0}; |
| } |
| uint32_t legacy_logger_feature_set; |
| std::tie(legacy_status, legacy_logger_feature_set) = |
| legacy_hal_.lock()->getLoggerSupportedFeatureSet(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| // some devices don't support querying logger feature set |
| legacy_logger_feature_set = 0; |
| } |
| uint32_t hidl_caps; |
| if (!hidl_struct_util::convertLegacyFeaturesToHidlStaCapabilities( |
| legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) { |
| return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0}; |
| } |
| return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps}; |
| } |
| |
| std::pair<WifiStatus, StaApfPacketFilterCapabilities> |
| 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 {createWifiStatusFromLegacyError(legacy_status), {}}; |
| } |
| StaApfPacketFilterCapabilities hidl_caps; |
| if (!hidl_struct_util::convertLegacyApfCapabilitiesToHidl(legacy_caps, |
| &hidl_caps)) { |
| return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; |
| } |
| return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps}; |
| } |
| |
| WifiStatus WifiStaIface::installApfPacketFilterInternal( |
| uint32_t /* cmd_id */, const std::vector<uint8_t>& program) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->setPacketFilter(ifname_, program); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<WifiStatus, std::vector<uint8_t>> |
| WifiStaIface::readApfPacketFilterDataInternal() { |
| const std::pair<legacy_hal::wifi_error, std::vector<uint8_t>> |
| legacy_status_and_data = |
| legacy_hal_.lock()->readApfPacketFilterData(ifname_); |
| return {createWifiStatusFromLegacyError(legacy_status_and_data.first), |
| std::move(legacy_status_and_data.second)}; |
| } |
| |
| std::pair<WifiStatus, StaBackgroundScanCapabilities> |
| 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 {createWifiStatusFromLegacyError(legacy_status), {}}; |
| } |
| StaBackgroundScanCapabilities hidl_caps; |
| if (!hidl_struct_util::convertLegacyGscanCapabilitiesToHidl(legacy_caps, |
| &hidl_caps)) { |
| return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; |
| } |
| return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps}; |
| } |
| |
| std::pair<WifiStatus, std::vector<WifiChannelInMhz>> |
| WifiStaIface::getValidFrequenciesForBandInternal(WifiBand band) { |
| static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), |
| "Size mismatch"); |
| legacy_hal::wifi_error legacy_status; |
| std::vector<uint32_t> valid_frequencies; |
| std::tie(legacy_status, valid_frequencies) = |
| legacy_hal_.lock()->getValidFrequenciesForBand( |
| ifname_, hidl_struct_util::convertHidlWifiBandToLegacy(band)); |
| return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies}; |
| } |
| |
| WifiStatus WifiStaIface::startBackgroundScanInternal( |
| uint32_t cmd_id, const StaBackgroundScanParameters& params) { |
| legacy_hal::wifi_scan_cmd_params legacy_params; |
| if (!hidl_struct_util::convertHidlGscanParamsToLegacy(params, |
| &legacy_params)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| android::wp<WifiStaIface> weak_ptr_this(this); |
| const auto& on_failure_callback = |
| [weak_ptr_this](legacy_hal::wifi_request_id id) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| 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.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| std::vector<StaScanData> hidl_scan_datas; |
| if (!hidl_struct_util:: |
| convertLegacyVectorOfCachedGscanResultsToHidl( |
| results, &hidl_scan_datas)) { |
| LOG(ERROR) << "Failed to convert scan results to HIDL structs"; |
| return; |
| } |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->onBackgroundScanResults(id, hidl_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.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| StaScanResult hidl_scan_result; |
| if (!hidl_struct_util::convertLegacyGscanResultToHidl( |
| *result, true, &hidl_scan_result)) { |
| LOG(ERROR) << "Failed to convert full scan results to HIDL structs"; |
| return; |
| } |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->onBackgroundFullScanResult(id, buckets_scanned, |
| hidl_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); |
| } |
| |
| WifiStatus WifiStaIface::stopBackgroundScanInternal(uint32_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->stopGscan(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->enableLinkLayerStats(ifname_, debug); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->disableLinkLayerStats(ifname_); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<WifiStatus, V1_0::StaLinkLayerStats> |
| WifiStaIface::getLinkLayerStatsInternal() { |
| return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}}; |
| } |
| |
| std::pair<WifiStatus, V1_3::StaLinkLayerStats> |
| WifiStaIface::getLinkLayerStatsInternal_1_3() { |
| legacy_hal::wifi_error legacy_status; |
| legacy_hal::LinkLayerStats legacy_stats; |
| std::tie(legacy_status, legacy_stats) = |
| legacy_hal_.lock()->getLinkLayerStats(ifname_); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| return {createWifiStatusFromLegacyError(legacy_status), {}}; |
| } |
| V1_3::StaLinkLayerStats hidl_stats; |
| if (!hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats, |
| &hidl_stats)) { |
| return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; |
| } |
| return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats}; |
| } |
| |
| WifiStatus WifiStaIface::startRssiMonitoringInternal(uint32_t cmd_id, |
| int32_t max_rssi, |
| int32_t min_rssi) { |
| android::wp<WifiStaIface> weak_ptr_this(this); |
| const auto& on_threshold_breached_callback = |
| [weak_ptr_this](legacy_hal::wifi_request_id id, |
| std::array<uint8_t, 6> bssid, int8_t rssi) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| 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); |
| } |
| |
| WifiStatus WifiStaIface::stopRssiMonitoringInternal(uint32_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->stopRssiMonitoring(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<WifiStatus, StaRoamingCapabilities> |
| 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 {createWifiStatusFromLegacyError(legacy_status), {}}; |
| } |
| StaRoamingCapabilities hidl_caps; |
| if (!hidl_struct_util::convertLegacyRoamingCapabilitiesToHidl(legacy_caps, |
| &hidl_caps)) { |
| return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; |
| } |
| return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps}; |
| } |
| |
| WifiStatus WifiStaIface::configureRoamingInternal( |
| const StaRoamingConfig& config) { |
| legacy_hal::wifi_roaming_config legacy_config; |
| if (!hidl_struct_util::convertHidlRoamingConfigToLegacy(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); |
| } |
| |
| WifiStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->enableFirmwareRoaming( |
| ifname_, hidl_struct_util::convertHidlRoamingStateToLegacy(state)); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiStaIface::enableNdOffloadInternal(bool enable) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->configureNdOffload(ifname_, enable); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiStaIface::startSendingKeepAlivePacketsInternal( |
| uint32_t cmd_id, const std::vector<uint8_t>& ip_packet_data, |
| uint16_t ether_type, const std::array<uint8_t, 6>& src_address, |
| const std::array<uint8_t, 6>& dst_address, uint32_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); |
| } |
| |
| WifiStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(uint32_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->stopSendingOffloadedPacket(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiStaIface::setScanningMacOuiInternal( |
| const std::array<uint8_t, 3>& oui) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->setScanningMacOui(ifname_, oui); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiStaIface::startDebugPacketFateMonitoringInternal() { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->startPktFateMonitoring(ifname_); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>> |
| 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 {createWifiStatusFromLegacyError(legacy_status), {}}; |
| } |
| std::vector<WifiDebugTxPacketFateReport> hidl_fates; |
| if (!hidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToHidl( |
| legacy_fates, &hidl_fates)) { |
| return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; |
| } |
| return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates}; |
| } |
| |
| std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>> |
| 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 {createWifiStatusFromLegacyError(legacy_status), {}}; |
| } |
| std::vector<WifiDebugRxPacketFateReport> hidl_fates; |
| if (!hidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToHidl( |
| legacy_fates, &hidl_fates)) { |
| return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; |
| } |
| return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates}; |
| } |
| |
| WifiStatus 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 createWifiStatus(WifiStatusCode::SUCCESS); |
| } |
| |
| std::pair<WifiStatus, std::array<uint8_t, 6>> |
| WifiStaIface::getFactoryMacAddressInternal() { |
| std::array<uint8_t, 6> mac; |
| return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), mac}; |
| } |
| |
| } // namespace implementation |
| } // namespace V1_3 |
| } // namespace wifi |
| } // namespace hardware |
| } // namespace android |