/* * 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_2 { namespace implementation { using hidl_return_util::validateAndCall; WifiStaIface::WifiStaIface( const std::string& ifname, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal) : ifname_(ifname), legacy_hal_(legacy_hal), 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::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); } 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, StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal() { 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), {}}; } 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, 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) { if (!iface_tool_.SetWifiUpState(false)) { LOG(ERROR) << "SetWifiUpState(false) failed."; return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); } if (!iface_tool_.SetMacAddress(ifname_.c_str(), mac)) { LOG(ERROR) << "SetMacAddress failed."; return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); } if (!iface_tool_.SetWifiUpState(true)) { LOG(ERROR) << "SetWifiUpState(true) failed."; return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); } LOG(DEBUG) << "Successfully SetMacAddress."; return createWifiStatus(WifiStatusCode::SUCCESS); } } // namespace implementation } // namespace V1_2 } // namespace wifi } // namespace hardware } // namespace android