Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:09:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert vendor HAL service to use new AIDL interface.

Browse Source 
Bug: 205044134
Test: Pass AIDL VTS tests and regression tests.
Change-Id: I286ffbf67efddc6c34d34ebd9e9bd9f36139c962
This commit is contained in:
Gabriel Biren
2022-07-15 23:25:39 +00:00
parent 6c5ff2565f
commit e58e263bce
87 changed files with 9769 additions and 8278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
wifi/1.6/default/android.hardware.wifi@1.0-service-lazy.rc
View File

@@ -1,14 +0,0 @@
service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi@1.0-service-lazy
interface android.hardware.wifi@1.0::IWifi default
interface android.hardware.wifi@1.1::IWifi default
interface android.hardware.wifi@1.2::IWifi default
interface android.hardware.wifi@1.3::IWifi default
interface android.hardware.wifi@1.4::IWifi default
interface android.hardware.wifi@1.5::IWifi default
interface android.hardware.wifi@1.6::IWifi default
oneshot
disabled
class hal
capabilities NET_ADMIN NET_RAW SYS_MODULE
user wifi
group wifi gps

12
wifi/1.6/default/android.hardware.wifi@1.0-service.rc
View File

@@ -1,12 +0,0 @@
service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi@1.0-service
interface android.hardware.wifi@1.0::IWifi default
interface android.hardware.wifi@1.1::IWifi default
interface android.hardware.wifi@1.2::IWifi default
interface android.hardware.wifi@1.3::IWifi default
interface android.hardware.wifi@1.4::IWifi default
interface android.hardware.wifi@1.5::IWifi default
interface android.hardware.wifi@1.6::IWifi default
class hal
capabilities NET_ADMIN NET_RAW SYS_MODULE
user wifi
group wifi gps

11
wifi/1.6/default/android.hardware.wifi@1.0-service.xml
View File

@@ -1,11 +0,0 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.wifi</name>
<transport>hwbinder</transport>
<version>1.6</version>
<interface>
<name>IWifi</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

122
wifi/1.6/default/hidl_callback_util.h
View File

@@ -1,122 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#ifndef HIDL_CALLBACK_UTIL_H_
#define HIDL_CALLBACK_UTIL_H_
#include <set>
#include <hidl/HidlSupport.h>
#include <hidl/HidlTransportSupport.h>
namespace {
// Type of callback invoked by the death handler.
using on_death_cb_function = std::function<void(uint64_t)>;
// Private class used to keep track of death of individual
// callbacks stored in HidlCallbackHandler.
template <typename CallbackType>
class HidlDeathHandler : public android::hardware::hidl_death_recipient {
public:
HidlDeathHandler(const on_death_cb_function& user_cb_function)
: cb_function_(user_cb_function) {}
~HidlDeathHandler() = default;
// Death notification for callbacks.
void serviceDied(uint64_t cookie,
const android::wp<android::hidl::base::V1_0::IBase>& /* who */) override {
cb_function_(cookie);
}
private:
on_death_cb_function cb_function_;
DISALLOW_COPY_AND_ASSIGN(HidlDeathHandler);
};
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_callback_util {
template <typename CallbackType>
// Provides a class to manage callbacks for the various HIDL interfaces and
// handle the death of the process hosting each callback.
class HidlCallbackHandler {
public:
HidlCallbackHandler()
: death_handler_(new HidlDeathHandler<CallbackType>(
std::bind(&HidlCallbackHandler::onObjectDeath, this, std::placeholders::_1))) {}
~HidlCallbackHandler() = default;
bool addCallback(const sp<CallbackType>& cb) {
// TODO(b/33818800): Can't compare proxies yet. So, use the cookie
// (callback proxy's raw pointer) to track the death of individual
// clients.
uint64_t cookie = reinterpret_cast<uint64_t>(cb.get());
for (const auto& s : cb_set_) {
if (interfacesEqual(cb, s)) {
LOG(ERROR) << "Duplicate death notification registration";
return true;
}
}
if (!cb->linkToDeath(death_handler_, cookie)) {
LOG(ERROR) << "Failed to register death notification";
return false;
}
cb_set_.insert(cb);
return true;
}
const std::set<android::sp<CallbackType>>& getCallbacks() { return cb_set_; }
// Death notification for callbacks.
void onObjectDeath(uint64_t cookie) {
CallbackType* cb = reinterpret_cast<CallbackType*>(cookie);
const auto& iter = cb_set_.find(cb);
if (iter == cb_set_.end()) {
LOG(ERROR) << "Unknown callback death notification received";
return;
}
cb_set_.erase(iter);
LOG(DEBUG) << "Dead callback removed from list";
}
void invalidate() {
for (const sp<CallbackType>& cb : cb_set_) {
if (!cb->unlinkToDeath(death_handler_)) {
LOG(ERROR) << "Failed to deregister death notification";
}
}
cb_set_.clear();
}
private:
std::set<sp<CallbackType>> cb_set_;
sp<HidlDeathHandler<CallbackType>> death_handler_;
DISALLOW_COPY_AND_ASSIGN(HidlCallbackHandler);
};
} // namespace hidl_callback_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_CALLBACK_UTIL_H_

118
wifi/1.6/default/hidl_return_util.h
View File

@@ -1,118 +0,0 @@
/*
* 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.
*/
#ifndef HIDL_RETURN_UTIL_H_
#define HIDL_RETURN_UTIL_H_
#include "hidl_sync_util.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_return_util {
using namespace android::hardware::wifi::V1_0;
/**
* These utility functions are used to invoke a method on the provided
* HIDL interface object.
* These functions checks if the provided HIDL interface object is valid.
* a) if valid, Invokes the corresponding internal implementation function of
* the HIDL method. It then invokes the HIDL continuation callback with
* the status and any returned values.
* b) if invalid, invokes the HIDL continuation callback with the
* provided error status and default values.
*/
// Use for HIDL methods which return only an instance of WifiStatus.
template <typename ObjT, typename WorkFuncT, typename... Args>
Return<void> validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
const std::function<void(const WifiStatus&)>& hidl_cb,
Args&&... args) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
hidl_cb((obj->*work)(std::forward<Args>(args)...));
} else {
hidl_cb(createWifiStatus(status_code_if_invalid));
}
return Void();
}
// Use for HIDL methods which return only an instance of WifiStatus.
// This version passes the global lock acquired to the body of the method.
// Note: Only used by IWifi::stop() currently.
template <typename ObjT, typename WorkFuncT, typename... Args>
Return<void> validateAndCallWithLock(ObjT* obj, WifiStatusCode status_code_if_invalid,
WorkFuncT&& work,
const std::function<void(const WifiStatus&)>& hidl_cb,
Args&&... args) {
auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
hidl_cb((obj->*work)(&lock, std::forward<Args>(args)...));
} else {
hidl_cb(createWifiStatus(status_code_if_invalid));
}
return Void();
}
// Use for HIDL methods which return instance of WifiStatus and a single return
// value.
template <typename ObjT, typename WorkFuncT, typename ReturnT, typename... Args>
Return<void> validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
const std::function<void(const WifiStatus&, ReturnT)>& hidl_cb,
Args&&... args) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
const auto& ret_pair = (obj->*work)(std::forward<Args>(args)...);
const WifiStatus& status = std::get<0>(ret_pair);
const auto& ret_value = std::get<1>(ret_pair);
hidl_cb(status, ret_value);
} else {
hidl_cb(createWifiStatus(status_code_if_invalid),
typename std::remove_reference<ReturnT>::type());
}
return Void();
}
// Use for HIDL methods which return instance of WifiStatus and 2 return
// values.
template <typename ObjT, typename WorkFuncT, typename ReturnT1, typename ReturnT2, typename... Args>
Return<void> validateAndCall(
ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
const std::function<void(const WifiStatus&, ReturnT1, ReturnT2)>& hidl_cb, Args&&... args) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
const auto& ret_tuple = (obj->*work)(std::forward<Args>(args)...);
const WifiStatus& status = std::get<0>(ret_tuple);
const auto& ret_value1 = std::get<1>(ret_tuple);
const auto& ret_value2 = std::get<2>(ret_tuple);
hidl_cb(status, ret_value1, ret_value2);
} else {
hidl_cb(createWifiStatus(status_code_if_invalid),
typename std::remove_reference<ReturnT1>::type(),
typename std::remove_reference<ReturnT2>::type());
}
return Void();
}
} // namespace hidl_return_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_RETURN_UTIL_H_

3007
wifi/1.6/default/hidl_struct_util.cpp
View File

File diff suppressed because it is too large Load Diff

204
wifi/1.6/default/hidl_struct_util.h
View File

@@ -1,204 +0,0 @@
/*
* 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.
*/
#ifndef HIDL_STRUCT_UTIL_H_
#define HIDL_STRUCT_UTIL_H_
#include <vector>
#include <android/hardware/wifi/1.0/IWifiChip.h>
#include <android/hardware/wifi/1.0/types.h>
#include <android/hardware/wifi/1.2/types.h>
#include <android/hardware/wifi/1.3/types.h>
#include <android/hardware/wifi/1.4/IWifiChipEventCallback.h>
#include <android/hardware/wifi/1.4/types.h>
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <android/hardware/wifi/1.6/types.h>
#include "wifi_legacy_hal.h"
/**
* This file contains a bunch of functions to convert structs from the legacy
* HAL to HIDL and vice versa.
* TODO(b/32093047): Add unit tests for these conversion methods in the VTS test
* suite.
*/
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_struct_util {
using namespace android::hardware::wifi::V1_0;
// Chip conversion methods.
bool convertLegacyFeaturesToHidlChipCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* hidl_caps);
bool convertLegacyDebugRingBufferStatusToHidl(
const legacy_hal::wifi_ring_buffer_status& legacy_status,
WifiDebugRingBufferStatus* hidl_status);
bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
std::vector<WifiDebugRingBufferStatus>* hidl_status_vec);
bool convertLegacyWakeReasonStatsToHidl(const legacy_hal::WakeReasonStats& legacy_stats,
WifiDebugHostWakeReasonStats* hidl_stats);
legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
V1_1::IWifiChip::TxPowerScenario hidl_scenario);
legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
V1_3::IWifiChip::LatencyMode hidl_latency_mode);
legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
V1_2::IWifiChip::TxPowerScenario hidl_scenario);
bool convertLegacyWifiMacInfosToHidl(
const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>* hidl_radio_mode_infos);
legacy_hal::wifi_interface_type convertHidlIfaceTypeToLegacy(IfaceType hidl_interface_type);
legacy_hal::wifi_multi_sta_use_case convertHidlMultiStaUseCaseToLegacy(
V1_5::IWifiChip::MultiStaUseCase use_case);
bool convertHidlCoexUnsafeChannelToLegacy(
const V1_5::IWifiChip::CoexUnsafeChannel& hidl_unsafe_channel,
legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel);
bool convertHidlVectorOfCoexUnsafeChannelToLegacy(
const std::vector<V1_5::IWifiChip::CoexUnsafeChannel>& hidl_unsafe_channels,
std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels);
bool convertLegacyRadioCombinationsMatrixToHidl(
legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
V1_6::WifiRadioCombinationMatrix* hidl_matrix);
V1_5::WifiBand convertLegacyMacBandToHidlWifiBand(uint32_t band);
V1_6::WifiAntennaMode convertLegacyAntennaConfigurationToHidl(uint32_t antenna_cfg);
// STA iface conversion methods.
bool convertLegacyFeaturesToHidlStaCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* hidl_caps);
bool convertLegacyApfCapabilitiesToHidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
StaApfPacketFilterCapabilities* hidl_caps);
bool convertLegacyGscanCapabilitiesToHidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
StaBackgroundScanCapabilities* hidl_caps);
legacy_hal::wifi_band convertHidlWifiBandToLegacy(V1_0::WifiBand band);
bool convertHidlGscanParamsToLegacy(const StaBackgroundScanParameters& hidl_scan_params,
legacy_hal::wifi_scan_cmd_params* legacy_scan_params);
// |has_ie_data| indicates whether or not the wifi_scan_result includes 802.11
// Information Elements (IEs)
bool convertLegacyGscanResultToHidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
bool has_ie_data, StaScanResult* hidl_scan_result);
// |cached_results| is assumed to not include IEs.
bool convertLegacyVectorOfCachedGscanResultsToHidl(
const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
std::vector<StaScanData>* hidl_scan_datas);
bool convertLegacyLinkLayerStatsToHidl(const legacy_hal::LinkLayerStats& legacy_stats,
V1_6::StaLinkLayerStats* hidl_stats);
bool convertLegacyRoamingCapabilitiesToHidl(
const legacy_hal::wifi_roaming_capabilities& legacy_caps,
StaRoamingCapabilities* hidl_caps);
bool convertHidlRoamingConfigToLegacy(const StaRoamingConfig& hidl_config,
legacy_hal::wifi_roaming_config* legacy_config);
legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(StaRoamingState state);
bool convertLegacyVectorOfDebugTxPacketFateToHidl(
const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
std::vector<WifiDebugTxPacketFateReport>* hidl_fates);
bool convertLegacyVectorOfDebugRxPacketFateToHidl(
const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
std::vector<WifiDebugRxPacketFateReport>* hidl_fates);
// NAN iface conversion methods.
void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
WifiNanStatus* wifiNanStatus);
bool convertHidlNanEnableRequestToLegacy(const V1_4::NanEnableRequest& hidl_request,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequestToLegacy(const V1_4::NanConfigRequest& hidl_request,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanEnableRequest_1_6ToLegacy(
const V1_4::NanEnableRequest& hidl_request1,
const V1_6::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequest_1_6ToLegacy(
const V1_4::NanConfigRequest& hidl_request1,
const V1_6::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanPublishRequestToLegacy(const V1_6::NanPublishRequest& hidl_request,
legacy_hal::NanPublishRequest* legacy_request);
bool convertHidlNanSubscribeRequestToLegacy(const V1_0::NanSubscribeRequest& hidl_request,
legacy_hal::NanSubscribeRequest* legacy_request);
bool convertHidlNanTransmitFollowupRequestToLegacy(
const NanTransmitFollowupRequest& hidl_request,
legacy_hal::NanTransmitFollowupRequest* legacy_request);
bool convertHidlNanDataPathInitiatorRequestToLegacy(
const V1_0::NanInitiateDataPathRequest& hidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request);
bool convertHidlNanDataPathIndicationResponseToLegacy(
const V1_0::NanRespondToDataPathIndicationRequest& hidl_response,
legacy_hal::NanDataPathIndicationResponse* legacy_response);
bool convertHidlNanDataPathInitiatorRequest_1_6ToLegacy(
const V1_6::NanInitiateDataPathRequest& hidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request);
bool convertHidlNanDataPathIndicationResponse_1_6ToLegacy(
const V1_6::NanRespondToDataPathIndicationRequest& hidl_response,
legacy_hal::NanDataPathIndicationResponse* legacy_response);
bool convertLegacyNanResponseHeaderToHidl(const legacy_hal::NanResponseMsg& legacy_response,
WifiNanStatus* wifiNanStatus);
bool convertLegacyNanCapabilitiesResponseToHidl(const legacy_hal::NanCapabilities& legacy_response,
V1_6::NanCapabilities* hidl_response);
bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
V1_6::NanMatchInd* hidl_ind);
bool convertLegacyNanFollowupIndToHidl(const legacy_hal::NanFollowupInd& legacy_ind,
NanFollowupReceivedInd* hidl_ind);
bool convertLegacyNanDataPathRequestIndToHidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
NanDataPathRequestInd* hidl_ind);
bool convertLegacyNanDataPathConfirmIndToHidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
V1_6::NanDataPathConfirmInd* hidl_ind);
bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
V1_6::NanDataPathScheduleUpdateInd* hidl_ind);
// RTT controller conversion methods.
bool convertHidlVectorOfRttConfigToLegacy(const std::vector<V1_6::RttConfig>& hidl_configs,
std::vector<legacy_hal::wifi_rtt_config>* legacy_configs);
bool convertHidlRttLciInformationToLegacy(const RttLciInformation& hidl_info,
legacy_hal::wifi_lci_information* legacy_info);
bool convertHidlRttLcrInformationToLegacy(const RttLcrInformation& hidl_info,
legacy_hal::wifi_lcr_information* legacy_info);
bool convertHidlRttResponderToLegacy(const V1_6::RttResponder& hidl_responder,
legacy_hal::wifi_rtt_responder* legacy_responder);
bool convertHidlWifiChannelInfoToLegacy(const V1_6::WifiChannelInfo& hidl_info,
legacy_hal::wifi_channel_info* legacy_info);
bool convertLegacyRttResponderToHidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
V1_6::RttResponder* hidl_responder);
bool convertLegacyRttCapabilitiesToHidl(
const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
V1_6::RttCapabilities* hidl_capabilities);
bool convertLegacyVectorOfRttResultToHidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
std::vector<V1_6::RttResult>* hidl_results);
uint32_t convertHidlWifiBandToLegacyMacBand(V1_5::WifiBand band);
uint32_t convertHidlWifiIfaceModeToLegacy(uint32_t hidl_iface_mask);
uint32_t convertHidlUsableChannelFilterToLegacy(uint32_t hidl_filter_mask);
bool convertLegacyWifiUsableChannelsToHidl(
const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
std::vector<V1_6::WifiUsableChannel>* hidl_usable_channels);
bool convertLegacyPeerInfoStatsToHidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
V1_6::StaPeerInfo* hidl_peer_info_stats);
bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
V1_6::WifiRateInfo* hidl_rate);
} // namespace hidl_struct_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_STRUCT_UTIL_H_

71
wifi/1.6/default/service.cpp
View File

@@ -1,71 +0,0 @@
/*
* 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/HidlLazyUtils.h>
#include <hidl/HidlTransportSupport.h>
#include <signal.h>
#include <utils/Looper.h>
#include <utils/StrongPointer.h>
#include "wifi.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_legacy_hal_factory.h"
#include "wifi_mode_controller.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::LazyServiceRegistrar;
using android::hardware::wifi::V1_6::implementation::feature_flags::WifiFeatureFlags;
using android::hardware::wifi::V1_6::implementation::legacy_hal::WifiLegacyHal;
using android::hardware::wifi::V1_6::implementation::legacy_hal::WifiLegacyHalFactory;
using android::hardware::wifi::V1_6::implementation::mode_controller::WifiModeController;
#ifdef LAZY_SERVICE
const bool kLazyService = true;
#else
const bool kLazyService = false;
#endif
int main(int /*argc*/, char** argv) {
signal(SIGPIPE, SIG_IGN);
android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
LOG(INFO) << "Wifi Hal is booting up...";
configureRpcThreadpool(1, true /* callerWillJoin */);
const auto iface_tool = std::make_shared<android::wifi_system::InterfaceTool>();
const auto legacy_hal_factory = std::make_shared<WifiLegacyHalFactory>(iface_tool);
// Setup hwbinder service
android::sp<android::hardware::wifi::V1_6::IWifi> service =
new android::hardware::wifi::V1_6::implementation::Wifi(
iface_tool, legacy_hal_factory, std::make_shared<WifiModeController>(),
std::make_shared<WifiFeatureFlags>());
if (kLazyService) {
auto registrar = LazyServiceRegistrar::getInstance();
CHECK_EQ(registrar.registerService(service), android::NO_ERROR)
<< "Failed to register wifi HAL";
} else {
CHECK_EQ(service->registerAsService(), android::NO_ERROR) << "Failed to register wifi HAL";
}
joinRpcThreadpool();
LOG(INFO) << "Wifi Hal is terminating...";
return 0;
}

138
wifi/1.6/default/tests/wifi_nan_iface_unit_tests.cpp
View File

@@ -1,138 +0,0 @@
/*
* Copyright (C) 2019, 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 <android-base/macros.h>
#include <cutils/properties.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "wifi_nan_iface.h"
#include "mock_interface_tool.h"
#include "mock_wifi_feature_flags.h"
#include "mock_wifi_iface_util.h"
#include "mock_wifi_legacy_hal.h"
using testing::NiceMock;
using testing::Return;
using testing::Test;
namespace {
constexpr char kIfaceName[] = "mockWlan0";
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using android::hardware::wifi::V1_2::NanDataPathConfirmInd;
bool CaptureIfaceEventHandlers(const std::string& /* iface_name*/,
iface_util::IfaceEventHandlers in_iface_event_handlers,
iface_util::IfaceEventHandlers* out_iface_event_handlers) {
*out_iface_event_handlers = in_iface_event_handlers;
return true;
}
class MockNanIfaceEventCallback : public V1_5::IWifiNanIfaceEventCallback {
public:
MockNanIfaceEventCallback() = default;
MOCK_METHOD3(notifyCapabilitiesResponse,
Return<void>(uint16_t, const WifiNanStatus&,
const android::hardware::wifi::V1_0::NanCapabilities&));
MOCK_METHOD2(notifyEnableResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyConfigResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyDisableResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD3(notifyStartPublishResponse, Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
MOCK_METHOD2(notifyStopPublishResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD3(notifyStartSubscribeResponse,
Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
MOCK_METHOD2(notifyStopSubscribeResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyTransmitFollowupResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyCreateDataInterfaceResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyDeleteDataInterfaceResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD3(notifyInitiateDataPathResponse,
Return<void>(uint16_t, const WifiNanStatus&, uint32_t));
MOCK_METHOD2(notifyRespondToDataPathIndicationResponse,
Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyTerminateDataPathResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD1(eventClusterEvent, Return<void>(const NanClusterEventInd&));
MOCK_METHOD1(eventDisabled, Return<void>(const WifiNanStatus&));
MOCK_METHOD2(eventPublishTerminated, Return<void>(uint8_t, const WifiNanStatus&));
MOCK_METHOD2(eventSubscribeTerminated, Return<void>(uint8_t, const WifiNanStatus&));
MOCK_METHOD1(eventMatch, Return<void>(const V1_0::NanMatchInd&));
MOCK_METHOD1(eventMatch_1_6, Return<void>(const NanMatchInd&));
MOCK_METHOD2(eventMatchExpired, Return<void>(uint8_t, uint32_t));
MOCK_METHOD1(eventFollowupReceived, Return<void>(const NanFollowupReceivedInd&));
MOCK_METHOD2(eventTransmitFollowup, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD1(eventDataPathRequest, Return<void>(const NanDataPathRequestInd&));
MOCK_METHOD1(eventDataPathConfirm,
Return<void>(const android::hardware::wifi::V1_0::NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathTerminated, Return<void>(uint32_t));
MOCK_METHOD1(eventDataPathConfirm_1_2,
Return<void>(const android::hardware::wifi::V1_2::NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathConfirm_1_6, Return<void>(const NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathScheduleUpdate,
Return<void>(const android::hardware::wifi::V1_2::NanDataPathScheduleUpdateInd&));
MOCK_METHOD1(eventDataPathScheduleUpdate_1_6,
Return<void>(const NanDataPathScheduleUpdateInd&));
MOCK_METHOD3(notifyCapabilitiesResponse_1_5,
Return<void>(uint16_t, const WifiNanStatus&, const V1_5::NanCapabilities&));
};
class WifiNanIfaceTest : public Test {
protected:
legacy_hal::wifi_hal_fn fake_func_table_;
std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<wifi_system::MockInterfaceTool>};
std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
};
TEST_F(WifiNanIfaceTest, IfacEventHandlers_OnStateToggleOffOn) {
iface_util::IfaceEventHandlers captured_iface_event_handlers = {};
EXPECT_CALL(*legacy_hal_, nanRegisterCallbackHandlers(testing::_, testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
EXPECT_CALL(*iface_util_, registerIfaceEventHandlers(testing::_, testing::_))
.WillOnce(testing::Invoke(bind(CaptureIfaceEventHandlers, std::placeholders::_1,
std::placeholders::_2, &captured_iface_event_handlers)));
sp<WifiNanIface> nan_iface = new WifiNanIface(kIfaceName, false, legacy_hal_, iface_util_);
// Register a mock nan event callback.
sp<NiceMock<MockNanIfaceEventCallback>> mock_event_callback{
new NiceMock<MockNanIfaceEventCallback>};
nan_iface->registerEventCallback(mock_event_callback, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
// Ensure that the eventDisabled() function in mock callback will be
// invoked.
WifiNanStatus expected_nan_status = {NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
EXPECT_CALL(*mock_event_callback, eventDisabled(expected_nan_status)).Times(1);
// Trigger the iface state toggle callback.
captured_iface_event_handlers.on_state_toggle_off_on(kIfaceName);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

105
wifi/1.6/default/wifi.h
View File

@@ -1,105 +0,0 @@
/*
* 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.
*/
#ifndef WIFI_H_
#define WIFI_H_
// HACK: NAN is a macro defined in math.h, which can be included in various
// headers. This wifi HAL uses an enum called NAN, which does not compile when
// the macro is defined. Undefine NAN to work around it.
#undef NAN
#include <android/hardware/wifi/1.6/IWifi.h>
#include <android-base/macros.h>
#include <utils/Looper.h>
#include <functional>
#include "hidl_callback_util.h"
#include "wifi_chip.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_legacy_hal_factory.h"
#include "wifi_mode_controller.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
/**
* Root HIDL interface object used to control the Wifi HAL.
*/
class Wifi : public V1_6::IWifi {
public:
Wifi(const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags);
bool isValid();
// HIDL methods exposed.
Return<void> registerEventCallback(const sp<V1_0::IWifiEventCallback>& event_callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_5(const sp<V1_5::IWifiEventCallback>& event_callback,
registerEventCallback_1_5_cb hidl_status_cb) override;
Return<bool> isStarted() override;
Return<void> start(start_cb hidl_status_cb) override;
Return<void> stop(stop_cb hidl_status_cb) override;
Return<void> getChipIds(getChipIds_cb hidl_status_cb) override;
Return<void> getChip(ChipId chip_id, getChip_cb hidl_status_cb) override;
Return<void> debug(const hidl_handle& handle, const hidl_vec<hidl_string>& options) override;
private:
enum class RunState { STOPPED, STARTED, STOPPING };
// Corresponding worker functions for the HIDL methods.
WifiStatus registerEventCallbackInternal(
const sp<V1_0::IWifiEventCallback>& event_callback __unused);
WifiStatus registerEventCallbackInternal_1_5(
const sp<V1_5::IWifiEventCallback>& event_callback);
WifiStatus startInternal();
WifiStatus stopInternal(std::unique_lock<std::recursive_mutex>* lock);
std::pair<WifiStatus, std::vector<ChipId>> getChipIdsInternal();
std::pair<WifiStatus, sp<V1_4::IWifiChip>> getChipInternal(ChipId chip_id);
WifiStatus initializeModeControllerAndLegacyHal();
WifiStatus stopLegacyHalAndDeinitializeModeController(
std::unique_lock<std::recursive_mutex>* lock);
ChipId getChipIdFromWifiChip(sp<WifiChip>& chip);
// Instance is created in this root level |IWifi| HIDL interface object
// and shared with all the child HIDL interface objects.
std::shared_ptr<wifi_system::InterfaceTool> iface_tool_;
std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory_;
std::shared_ptr<mode_controller::WifiModeController> mode_controller_;
std::vector<std::shared_ptr<legacy_hal::WifiLegacyHal>> legacy_hals_;
std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags_;
RunState run_state_;
std::vector<sp<WifiChip>> chips_;
hidl_callback_util::HidlCallbackHandler<V1_5::IWifiEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(Wifi);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_H_

89
wifi/1.6/default/wifi_ap_iface.h
View File

@@ -1,89 +0,0 @@
/*
* 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.
*/
#ifndef WIFI_AP_IFACE_H_
#define WIFI_AP_IFACE_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.5/IWifiApIface.h>
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
/**
* HIDL interface object used to control a AP Iface instance.
*/
class WifiApIface : public V1_5::IWifiApIface {
public:
WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::string getName();
void removeInstance(std::string instance);
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
Return<void> setCountryCode(const hidl_array<int8_t, 2>& code,
setCountryCode_cb hidl_status_cb) override;
Return<void> getValidFrequenciesForBand(V1_0::WifiBand band,
getValidFrequenciesForBand_cb hidl_status_cb) override;
Return<void> setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) override;
Return<void> getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) override;
Return<void> resetToFactoryMacAddress(resetToFactoryMacAddress_cb hidl_status_cb) override;
Return<void> getBridgedInstances(getBridgedInstances_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code);
std::pair<WifiStatus, std::vector<WifiChannelInMhz>> getValidFrequenciesForBandInternal(
V1_0::WifiBand band);
WifiStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
std::pair<WifiStatus, std::array<uint8_t, 6>> getFactoryMacAddressInternal(
const std::string& ifaceName);
WifiStatus resetToFactoryMacAddressInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getBridgedInstancesInternal();
std::string ifname_;
std::vector<std::string> instances_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
DISALLOW_COPY_AND_ASSIGN(WifiApIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_AP_IFACE_H_

317
wifi/1.6/default/wifi_chip.h
View File

@@ -1,317 +0,0 @@
/*
* 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.
*/
#ifndef WIFI_CHIP_H_
#define WIFI_CHIP_H_
// HACK: NAN is a macro defined in math.h, which can be included in various
// headers. This wifi HAL uses an enum called NAN, which does not compile when
// the macro is defined. Undefine NAN to work around it.
#undef NAN
#include <list>
#include <map>
#include <mutex>
#include <android-base/macros.h>
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <android/hardware/wifi/1.6/IWifiRttController.h>
#include <android/hardware/wifi/1.6/IWifiStaIface.h>
#include "hidl_callback_util.h"
#include "ringbuffer.h"
#include "wifi_ap_iface.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_mode_controller.h"
#include "wifi_nan_iface.h"
#include "wifi_p2p_iface.h"
#include "wifi_rtt_controller.h"
#include "wifi_sta_iface.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using V1_5::WifiBand;
/**
* HIDL interface object used to control a Wifi HAL chip instance.
* Since there is only a single chip instance used today, there is no
* identifying handle information stored here.
*/
class WifiChip : public V1_6::IWifiChip {
public:
WifiChip(ChipId chip_id, bool is_primary,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
const std::function<void(const std::string&)>& subsystemCallbackHandler);
// HIDL does not provide a built-in mechanism to let the server invalidate
// a HIDL interface object after creation. If any client process holds onto
// a reference to the object in their context, any method calls on that
// reference will continue to be directed to the server.
//
// However Wifi HAL needs to control the lifetime of these objects. So, add
// a public |invalidate| method to |WifiChip| and it's child objects. This
// will be used to mark an object invalid when either:
// a) Wifi HAL is stopped, or
// b) Wifi Chip is reconfigured.
//
// All HIDL method implementations should check if the object is still
// marked valid before processing them.
void invalidate();
bool isValid();
std::set<sp<V1_4::IWifiChipEventCallback>> getEventCallbacks();
// HIDL methods exposed.
Return<void> getId(getId_cb hidl_status_cb) override;
// Deprecated support for this callback
Return<void> registerEventCallback(const sp<V1_0::IWifiChipEventCallback>& event_callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
Return<void> getAvailableModes(getAvailableModes_cb hidl_status_cb) override;
Return<void> configureChip(ChipModeId mode_id, configureChip_cb hidl_status_cb) override;
Return<void> getMode(getMode_cb hidl_status_cb) override;
Return<void> requestChipDebugInfo(requestChipDebugInfo_cb hidl_status_cb) override;
Return<void> requestDriverDebugDump(requestDriverDebugDump_cb hidl_status_cb) override;
Return<void> requestFirmwareDebugDump(requestFirmwareDebugDump_cb hidl_status_cb) override;
Return<void> createApIface(createApIface_cb hidl_status_cb) override;
Return<void> createBridgedApIface(createBridgedApIface_cb hidl_status_cb) override;
Return<void> getApIfaceNames(getApIfaceNames_cb hidl_status_cb) override;
Return<void> getApIface(const hidl_string& ifname, getApIface_cb hidl_status_cb) override;
Return<void> removeApIface(const hidl_string& ifname, removeApIface_cb hidl_status_cb) override;
Return<void> removeIfaceInstanceFromBridgedApIface(
const hidl_string& brIfaceName, const hidl_string& ifaceInstanceName,
removeIfaceInstanceFromBridgedApIface_cb hidl_status_cb) override;
Return<void> createNanIface(createNanIface_cb hidl_status_cb) override;
Return<void> getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) override;
Return<void> getNanIface(const hidl_string& ifname, getNanIface_cb hidl_status_cb) override;
Return<void> removeNanIface(const hidl_string& ifname,
removeNanIface_cb hidl_status_cb) override;
Return<void> createP2pIface(createP2pIface_cb hidl_status_cb) override;
Return<void> getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) override;
Return<void> getP2pIface(const hidl_string& ifname, getP2pIface_cb hidl_status_cb) override;
Return<void> removeP2pIface(const hidl_string& ifname,
removeP2pIface_cb hidl_status_cb) override;
Return<void> createStaIface(createStaIface_cb hidl_status_cb) override;
Return<void> getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) override;
Return<void> getStaIface(const hidl_string& ifname, getStaIface_cb hidl_status_cb) override;
Return<void> removeStaIface(const hidl_string& ifname,
removeStaIface_cb hidl_status_cb) override;
Return<void> createRttController(const sp<IWifiIface>& bound_iface,
createRttController_cb hidl_status_cb) override;
Return<void> getDebugRingBuffersStatus(getDebugRingBuffersStatus_cb hidl_status_cb) override;
Return<void> startLoggingToDebugRingBuffer(
const hidl_string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes,
startLoggingToDebugRingBuffer_cb hidl_status_cb) override;
Return<void> forceDumpToDebugRingBuffer(const hidl_string& ring_name,
forceDumpToDebugRingBuffer_cb hidl_status_cb) override;
Return<void> flushRingBufferToFile(flushRingBufferToFile_cb hidl_status_cb) override;
Return<void> stopLoggingToDebugRingBuffer(
stopLoggingToDebugRingBuffer_cb hidl_status_cb) override;
Return<void> getDebugHostWakeReasonStats(
getDebugHostWakeReasonStats_cb hidl_status_cb) override;
Return<void> enableDebugErrorAlerts(bool enable,
enableDebugErrorAlerts_cb hidl_status_cb) override;
Return<void> selectTxPowerScenario(V1_1::IWifiChip::TxPowerScenario scenario,
selectTxPowerScenario_cb hidl_status_cb) override;
Return<void> resetTxPowerScenario(resetTxPowerScenario_cb hidl_status_cb) override;
Return<void> setLatencyMode(LatencyMode mode, setLatencyMode_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_2(const sp<V1_2::IWifiChipEventCallback>& event_callback,
registerEventCallback_1_2_cb hidl_status_cb) override;
Return<void> selectTxPowerScenario_1_2(TxPowerScenario scenario,
selectTxPowerScenario_cb hidl_status_cb) override;
Return<void> getCapabilities_1_3(getCapabilities_cb hidl_status_cb) override;
Return<void> getCapabilities_1_5(getCapabilities_1_5_cb hidl_status_cb) override;
Return<void> debug(const hidl_handle& handle, const hidl_vec<hidl_string>& options) override;
Return<void> createRttController_1_4(const sp<IWifiIface>& bound_iface,
createRttController_1_4_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_4(const sp<V1_4::IWifiChipEventCallback>& event_callback,
registerEventCallback_1_4_cb hidl_status_cb) override;
Return<void> setMultiStaPrimaryConnection(
const hidl_string& ifname, setMultiStaPrimaryConnection_cb hidl_status_cb) override;
Return<void> setMultiStaUseCase(MultiStaUseCase use_case,
setMultiStaUseCase_cb hidl_status_cb) override;
Return<void> setCoexUnsafeChannels(const hidl_vec<CoexUnsafeChannel>& unsafe_channels,
hidl_bitfield<IfaceType> restrictions,
setCoexUnsafeChannels_cb hidl_status_cb) override;
Return<void> setCountryCode(const hidl_array<int8_t, 2>& code,
setCountryCode_cb _hidl_cb) override;
Return<void> getUsableChannels(WifiBand band, hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
hidl_bitfield<V1_5::IWifiChip::UsableChannelFilter> filterMask,
getUsableChannels_cb _hidl_cb) override;
Return<void> triggerSubsystemRestart(triggerSubsystemRestart_cb hidl_status_cb) override;
Return<void> createRttController_1_6(const sp<IWifiIface>& bound_iface,
createRttController_1_6_cb hidl_status_cb) override;
Return<void> getUsableChannels_1_6(WifiBand band,
hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
hidl_bitfield<UsableChannelFilter> filterMask,
getUsableChannels_1_6_cb _hidl_cb) override;
Return<void> getSupportedRadioCombinationsMatrix(
getSupportedRadioCombinationsMatrix_cb hidl_status_cb) override;
Return<void> getAvailableModes_1_6(getAvailableModes_1_6_cb hidl_status_cb) override;
private:
void invalidateAndRemoveAllIfaces();
// When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are
// invalidated & removed.
void invalidateAndRemoveDependencies(const std::string& removed_iface_name);
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, ChipId> getIdInternal();
// Deprecated support for this callback
WifiStatus registerEventCallbackInternal(
const sp<V1_0::IWifiChipEventCallback>& event_callback);
std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
std::pair<WifiStatus, std::vector<V1_0::IWifiChip::ChipMode>> getAvailableModesInternal();
WifiStatus configureChipInternal(std::unique_lock<std::recursive_mutex>* lock,
ChipModeId mode_id);
std::pair<WifiStatus, uint32_t> getModeInternal();
std::pair<WifiStatus, IWifiChip::ChipDebugInfo> requestChipDebugInfoInternal();
std::pair<WifiStatus, std::vector<uint8_t>> requestDriverDebugDumpInternal();
std::pair<WifiStatus, std::vector<uint8_t>> requestFirmwareDebugDumpInternal();
sp<WifiApIface> newWifiApIface(std::string& ifname);
WifiStatus createVirtualApInterface(const std::string& apVirtIf);
std::pair<WifiStatus, sp<V1_5::IWifiApIface>> createApIfaceInternal();
std::pair<WifiStatus, sp<V1_5::IWifiApIface>> createBridgedApIfaceInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getApIfaceNamesInternal();
std::pair<WifiStatus, sp<V1_5::IWifiApIface>> getApIfaceInternal(const std::string& ifname);
WifiStatus removeApIfaceInternal(const std::string& ifname);
WifiStatus removeIfaceInstanceFromBridgedApIfaceInternal(const std::string& brIfaceName,
const std::string& ifInstanceName);
std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> createNanIfaceInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getNanIfaceNamesInternal();
std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> getNanIfaceInternal(const std::string& ifname);
WifiStatus removeNanIfaceInternal(const std::string& ifname);
std::pair<WifiStatus, sp<IWifiP2pIface>> createP2pIfaceInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getP2pIfaceNamesInternal();
std::pair<WifiStatus, sp<IWifiP2pIface>> getP2pIfaceInternal(const std::string& ifname);
WifiStatus removeP2pIfaceInternal(const std::string& ifname);
std::pair<WifiStatus, sp<V1_6::IWifiStaIface>> createStaIfaceInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal();
std::pair<WifiStatus, sp<V1_6::IWifiStaIface>> getStaIfaceInternal(const std::string& ifname);
WifiStatus removeStaIfaceInternal(const std::string& ifname);
std::pair<WifiStatus, sp<V1_0::IWifiRttController>> createRttControllerInternal(
const sp<IWifiIface>& bound_iface);
std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
getDebugRingBuffersStatusInternal();
WifiStatus startLoggingToDebugRingBufferInternal(const hidl_string& ring_name,
WifiDebugRingBufferVerboseLevel verbose_level,
uint32_t max_interval_in_sec,
uint32_t min_data_size_in_bytes);
WifiStatus forceDumpToDebugRingBufferInternal(const hidl_string& ring_name);
WifiStatus flushRingBufferToFileInternal();
WifiStatus stopLoggingToDebugRingBufferInternal();
std::pair<WifiStatus, WifiDebugHostWakeReasonStats> getDebugHostWakeReasonStatsInternal();
WifiStatus enableDebugErrorAlertsInternal(bool enable);
WifiStatus selectTxPowerScenarioInternal(V1_1::IWifiChip::TxPowerScenario scenario);
WifiStatus resetTxPowerScenarioInternal();
WifiStatus setLatencyModeInternal(LatencyMode mode);
WifiStatus registerEventCallbackInternal_1_2(
const sp<V1_2::IWifiChipEventCallback>& event_callback);
WifiStatus selectTxPowerScenarioInternal_1_2(TxPowerScenario scenario);
std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_3();
std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_5();
std::pair<WifiStatus, sp<V1_4::IWifiRttController>> createRttControllerInternal_1_4(
const sp<IWifiIface>& bound_iface);
WifiStatus registerEventCallbackInternal_1_4(
const sp<V1_4::IWifiChipEventCallback>& event_callback);
WifiStatus setMultiStaPrimaryConnectionInternal(const std::string& ifname);
WifiStatus setMultiStaUseCaseInternal(MultiStaUseCase use_case);
WifiStatus setCoexUnsafeChannelsInternal(std::vector<CoexUnsafeChannel> unsafe_channels,
uint32_t restrictions);
WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code);
std::pair<WifiStatus, std::vector<V1_5::WifiUsableChannel>> getUsableChannelsInternal(
WifiBand band, uint32_t ifaceModeMask, uint32_t filterMask);
WifiStatus handleChipConfiguration(std::unique_lock<std::recursive_mutex>* lock,
ChipModeId mode_id);
WifiStatus registerDebugRingBufferCallback();
WifiStatus registerRadioModeChangeCallback();
std::vector<V1_6::IWifiChip::ChipConcurrencyCombination>
getCurrentModeConcurrencyCombinations();
std::map<IfaceConcurrencyType, size_t> getCurrentConcurrencyCombination();
std::vector<std::map<IfaceConcurrencyType, size_t>> expandConcurrencyCombinations(
const V1_6::IWifiChip::ChipConcurrencyCombination& combination);
bool canExpandedConcurrencyComboSupportConcurrencyTypeWithCurrentTypes(
const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
IfaceConcurrencyType requested_type);
bool canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType requested_type);
bool canExpandedConcurrencyComboSupportConcurrencyCombo(
const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
const std::map<IfaceConcurrencyType, size_t>& req_combo);
bool canCurrentModeSupportConcurrencyCombo(
const std::map<IfaceConcurrencyType, size_t>& req_combo);
bool canCurrentModeSupportConcurrencyType(IfaceConcurrencyType requested_type);
bool isValidModeId(ChipModeId mode_id);
bool isStaApConcurrencyAllowedInCurrentMode();
bool isDualStaConcurrencyAllowedInCurrentMode();
uint32_t startIdxOfApIface();
std::string getFirstActiveWlanIfaceName();
std::string allocateApOrStaIfaceName(IfaceType type, uint32_t start_idx);
std::string allocateApIfaceName();
std::vector<std::string> allocateBridgedApInstanceNames();
std::string allocateStaIfaceName();
bool writeRingbufferFilesInternal();
std::string getWlanIfaceNameWithType(IfaceType type, unsigned idx);
void invalidateAndClearBridgedApAll();
void deleteApIface(const std::string& if_name);
bool findUsingNameFromBridgedApInstances(const std::string& name);
WifiStatus triggerSubsystemRestartInternal();
std::pair<WifiStatus, sp<V1_6::IWifiRttController>> createRttControllerInternal_1_6(
const sp<IWifiIface>& bound_iface);
std::pair<WifiStatus, std::vector<V1_6::WifiUsableChannel>> getUsableChannelsInternal_1_6(
WifiBand band, uint32_t ifaceModeMask, uint32_t filterMask);
std::pair<WifiStatus, WifiRadioCombinationMatrix> getSupportedRadioCombinationsMatrixInternal();
std::pair<WifiStatus, std::vector<V1_6::IWifiChip::ChipMode>> getAvailableModesInternal_1_6();
ChipId chip_id_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<mode_controller::WifiModeController> mode_controller_;
std::shared_ptr<iface_util::WifiIfaceUtil> iface_util_;
std::vector<sp<WifiApIface>> ap_ifaces_;
std::vector<sp<WifiNanIface>> nan_ifaces_;
std::vector<sp<WifiP2pIface>> p2p_ifaces_;
std::vector<sp<WifiStaIface>> sta_ifaces_;
std::vector<sp<WifiRttController>> rtt_controllers_;
std::map<std::string, Ringbuffer> ringbuffer_map_;
bool is_valid_;
// Members pertaining to chip configuration.
uint32_t current_mode_id_;
std::mutex lock_t;
std::vector<V1_6::IWifiChip::ChipMode> modes_;
// The legacy ring buffer callback API has only a global callback
// registration mechanism. Use this to check if we have already
// registered a callback.
bool debug_ring_buffer_cb_registered_;
hidl_callback_util::HidlCallbackHandler<V1_4::IWifiChipEventCallback> event_cb_handler_;
const std::function<void(const std::string&)> subsystemCallbackHandler_;
std::map<std::string, std::vector<std::string>> br_ifaces_ap_instances_;
DISALLOW_COPY_AND_ASSIGN(WifiChip);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_CHIP_H_

1016
wifi/1.6/default/wifi_nan_iface.cpp
View File

File diff suppressed because it is too large Load Diff

208
wifi/1.6/default/wifi_nan_iface.h
View File

@@ -1,208 +0,0 @@
/*
* 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.
*/
#ifndef WIFI_NAN_IFACE_H_
#define WIFI_NAN_IFACE_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.6/IWifiNanIface.h>
#include <android/hardware/wifi/1.6/IWifiNanIfaceEventCallback.h>
#include "hidl_callback_util.h"
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using namespace android::hardware::wifi::V1_2;
using namespace android::hardware::wifi::V1_4;
using namespace android::hardware::wifi::V1_6;
/**
* HIDL interface object used to control a NAN Iface instance.
*/
class WifiNanIface : public V1_6::IWifiNanIface {
public:
WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::string getName();
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
Return<void> registerEventCallback(const sp<V1_0::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> getCapabilitiesRequest(uint16_t cmd_id,
getCapabilitiesRequest_cb hidl_status_cb) override;
Return<void> enableRequest(uint16_t cmd_id, const V1_0::NanEnableRequest& msg,
enableRequest_cb hidl_status_cb) override;
Return<void> configRequest(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
configRequest_cb hidl_status_cb) override;
Return<void> disableRequest(uint16_t cmd_id, disableRequest_cb hidl_status_cb) override;
Return<void> startPublishRequest(uint16_t cmd_id, const V1_0::NanPublishRequest& msg,
startPublishRequest_cb hidl_status_cb) override;
Return<void> stopPublishRequest(uint16_t cmd_id, uint8_t sessionId,
stopPublishRequest_cb hidl_status_cb) override;
Return<void> startSubscribeRequest(uint16_t cmd_id, const V1_0::NanSubscribeRequest& msg,
startSubscribeRequest_cb hidl_status_cb) override;
Return<void> stopSubscribeRequest(uint16_t cmd_id, uint8_t sessionId,
stopSubscribeRequest_cb hidl_status_cb) override;
Return<void> transmitFollowupRequest(uint16_t cmd_id, const NanTransmitFollowupRequest& msg,
transmitFollowupRequest_cb hidl_status_cb) override;
Return<void> createDataInterfaceRequest(uint16_t cmd_id, const hidl_string& iface_name,
createDataInterfaceRequest_cb hidl_status_cb) override;
Return<void> deleteDataInterfaceRequest(uint16_t cmd_id, const hidl_string& iface_name,
deleteDataInterfaceRequest_cb hidl_status_cb) override;
Return<void> initiateDataPathRequest(uint16_t cmd_id,
const V1_0::NanInitiateDataPathRequest& msg,
initiateDataPathRequest_cb hidl_status_cb) override;
Return<void> respondToDataPathIndicationRequest(
uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg,
respondToDataPathIndicationRequest_cb hidl_status_cb) override;
Return<void> terminateDataPathRequest(uint16_t cmd_id, uint32_t ndpInstanceId,
terminateDataPathRequest_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_2(const sp<V1_2::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_2_cb hidl_status_cb) override;
Return<void> enableRequest_1_2(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
enableRequest_1_2_cb hidl_status_cb) override;
Return<void> configRequest_1_2(uint16_t cmd_id, const V1_0::NanConfigRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
configRequest_1_2_cb hidl_status_cb) override;
Return<void> enableRequest_1_4(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
enableRequest_1_4_cb hidl_status_cb) override;
Return<void> configRequest_1_4(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
configRequest_1_4_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_5(const sp<V1_5::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_5_cb hidl_status_cb) override;
Return<void> enableRequest_1_5(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2,
enableRequest_1_5_cb hidl_status_cb) override;
Return<void> configRequest_1_5(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2,
configRequest_1_5_cb hidl_status_cb) override;
Return<void> getCapabilitiesRequest_1_5(uint16_t cmd_id,
getCapabilitiesRequest_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_6(const sp<V1_6::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_6_cb hidl_status_cb) override;
Return<void> initiateDataPathRequest_1_6(
uint16_t cmd_id, const V1_6::NanInitiateDataPathRequest& msg,
initiateDataPathRequest_1_6_cb hidl_status_cb) override;
Return<void> respondToDataPathIndicationRequest_1_6(
uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg,
respondToDataPathIndicationRequest_1_6_cb hidl_status_cb) override;
Return<void> enableRequest_1_6(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_6::NanConfigRequestSupplemental& msg2,
enableRequest_1_6_cb hidl_status_cb) override;
Return<void> configRequest_1_6(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_6::NanConfigRequestSupplemental& msg2,
configRequest_1_6_cb hidl_status_cb) override;
Return<void> startPublishRequest_1_6(uint16_t cmd_id, const V1_6::NanPublishRequest& msg,
startPublishRequest_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
WifiStatus registerEventCallbackInternal(const sp<V1_0::IWifiNanIfaceEventCallback>& callback);
WifiStatus getCapabilitiesRequestInternal(uint16_t cmd_id);
WifiStatus enableRequestInternal(uint16_t cmd_id, const V1_0::NanEnableRequest& msg);
WifiStatus configRequestInternal(uint16_t cmd_id, const V1_0::NanConfigRequest& msg);
WifiStatus disableRequestInternal(uint16_t cmd_id);
WifiStatus startPublishRequestInternal(uint16_t cmd_id, const V1_0::NanPublishRequest& msg);
WifiStatus stopPublishRequestInternal(uint16_t cmd_id, uint8_t sessionId);
WifiStatus startSubscribeRequestInternal(uint16_t cmd_id, const V1_0::NanSubscribeRequest& msg);
WifiStatus stopSubscribeRequestInternal(uint16_t cmd_id, uint8_t sessionId);
WifiStatus transmitFollowupRequestInternal(uint16_t cmd_id,
const NanTransmitFollowupRequest& msg);
WifiStatus createDataInterfaceRequestInternal(uint16_t cmd_id, const std::string& iface_name);
WifiStatus deleteDataInterfaceRequestInternal(uint16_t cmd_id, const std::string& iface_name);
WifiStatus initiateDataPathRequestInternal(uint16_t cmd_id,
const V1_0::NanInitiateDataPathRequest& msg);
WifiStatus respondToDataPathIndicationRequestInternal(
uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg);
WifiStatus terminateDataPathRequestInternal(uint16_t cmd_id, uint32_t ndpInstanceId);
WifiStatus registerEventCallback_1_2Internal(
const sp<V1_2::IWifiNanIfaceEventCallback>& callback);
WifiStatus enableRequest_1_2Internal(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_2Internal(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus enableRequest_1_4Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_4Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus registerEventCallback_1_5Internal(
const sp<V1_5::IWifiNanIfaceEventCallback>& callback);
WifiStatus enableRequest_1_5Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_5Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
const V1_5::NanConfigRequestSupplemental& msg2);
WifiStatus getCapabilitiesRequest_1_5Internal(uint16_t cmd_id);
WifiStatus registerEventCallback_1_6Internal(
const sp<V1_6::IWifiNanIfaceEventCallback>& callback);
WifiStatus enableRequest_1_6Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_6::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_6Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
const V1_6::NanConfigRequestSupplemental& msg2);
WifiStatus startPublishRequest_1_6Internal(uint16_t cmd_id, const V1_6::NanPublishRequest& msg);
WifiStatus initiateDataPathRequest_1_6Internal(uint16_t cmd_id,
const V1_6::NanInitiateDataPathRequest& msg);
WifiStatus respondToDataPathIndicationRequest_1_6Internal(
uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg);
// all 1_0 and descendant callbacks
std::set<sp<V1_0::IWifiNanIfaceEventCallback>> getEventCallbacks();
// all 1_2 and descendant callbacks
std::set<sp<V1_2::IWifiNanIfaceEventCallback>> getEventCallbacks_1_2();
// all 1_5 and descendant callbacks
std::set<sp<V1_5::IWifiNanIfaceEventCallback>> getEventCallbacks_1_5();
// all 1_6 and descendant callbacks
std::set<sp<V1_6::IWifiNanIfaceEventCallback>> getEventCallbacks_1_6();
std::string ifname_;
bool is_dedicated_iface_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
hidl_callback_util::HidlCallbackHandler<V1_0::IWifiNanIfaceEventCallback> event_cb_handler_;
hidl_callback_util::HidlCallbackHandler<V1_2::IWifiNanIfaceEventCallback> event_cb_handler_1_2_;
hidl_callback_util::HidlCallbackHandler<V1_5::IWifiNanIfaceEventCallback> event_cb_handler_1_5_;
hidl_callback_util::HidlCallbackHandler<V1_6::IWifiNanIfaceEventCallback> event_cb_handler_1_6_;
DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_NAN_IFACE_H_

377
wifi/1.6/default/wifi_rtt_controller.cpp
View File

@@ -1,377 +0,0 @@
/*
* 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_rtt_controller.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
WifiRttController::WifiRttController(const std::string& iface_name,
const sp<IWifiIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: ifname_(iface_name), bound_iface_(bound_iface), legacy_hal_(legacy_hal), is_valid_(true) {}
void WifiRttController::invalidate() {
legacy_hal_.reset();
event_callbacks_.clear();
is_valid_ = false;
}
bool WifiRttController::isValid() {
return is_valid_;
}
std::vector<sp<V1_6::IWifiRttControllerEventCallback>> WifiRttController::getEventCallbacks() {
return event_callbacks_;
}
std::string WifiRttController::getIfaceName() {
return ifname_;
}
Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getBoundIfaceInternal, hidl_status_cb);
}
Return<void> WifiRttController::registerEventCallback(
const sp<V1_0::IWifiRttControllerEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::registerEventCallbackInternal, hidl_status_cb,
callback);
}
Return<void> WifiRttController::rangeRequest(uint32_t cmd_id,
const hidl_vec<V1_0::RttConfig>& rtt_configs,
rangeRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeRequestInternal, hidl_status_cb, cmd_id,
rtt_configs);
}
Return<void> WifiRttController::rangeCancel(uint32_t cmd_id,
const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
rangeCancel_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeCancelInternal, hidl_status_cb, cmd_id, addrs);
}
Return<void> WifiRttController::getCapabilities(getCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiRttController::setLci(uint32_t cmd_id, const RttLciInformation& lci,
setLci_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::setLciInternal, hidl_status_cb, cmd_id, lci);
}
Return<void> WifiRttController::setLcr(uint32_t cmd_id, const RttLcrInformation& lcr,
setLcr_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::setLcrInternal, hidl_status_cb, cmd_id, lcr);
}
Return<void> WifiRttController::getResponderInfo(getResponderInfo_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getResponderInfoInternal, hidl_status_cb);
}
Return<void> WifiRttController::enableResponder(uint32_t cmd_id,
const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_0::RttResponder& info,
enableResponder_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::enableResponderInternal, hidl_status_cb, cmd_id,
channel_hint, max_duration_seconds, info);
}
Return<void> WifiRttController::disableResponder(uint32_t cmd_id,
disableResponder_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::disableResponderInternal, hidl_status_cb, cmd_id);
}
Return<void> WifiRttController::registerEventCallback_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::registerEventCallbackInternal_1_4, hidl_status_cb,
callback);
}
Return<void> WifiRttController::rangeRequest_1_4(uint32_t cmd_id,
const hidl_vec<V1_4::RttConfig>& rtt_configs,
rangeRequest_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeRequestInternal_1_4, hidl_status_cb, cmd_id,
rtt_configs);
}
Return<void> WifiRttController::getCapabilities_1_4(getCapabilities_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getCapabilitiesInternal_1_4, hidl_status_cb);
}
Return<void> WifiRttController::getResponderInfo_1_4(getResponderInfo_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getResponderInfoInternal_1_4, hidl_status_cb);
}
Return<void> WifiRttController::enableResponder_1_4(uint32_t cmd_id,
const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_4::RttResponder& info,
enableResponder_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::enableResponderInternal_1_4, hidl_status_cb, cmd_id,
channel_hint, max_duration_seconds, info);
}
Return<void> WifiRttController::registerEventCallback_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::registerEventCallbackInternal_1_6, hidl_status_cb,
callback);
}
Return<void> WifiRttController::rangeRequest_1_6(uint32_t cmd_id,
const hidl_vec<V1_6::RttConfig>& rtt_configs,
rangeRequest_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeRequestInternal_1_6, hidl_status_cb, cmd_id,
rtt_configs);
}
Return<void> WifiRttController::getCapabilities_1_6(getCapabilities_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getCapabilitiesInternal_1_6, hidl_status_cb);
}
Return<void> WifiRttController::getResponderInfo_1_6(getResponderInfo_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getResponderInfoInternal_1_6, hidl_status_cb);
}
Return<void> WifiRttController::enableResponder_1_6(uint32_t cmd_id,
const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_6::RttResponder& info,
enableResponder_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::enableResponderInternal_1_6, hidl_status_cb, cmd_id,
channel_hint, max_duration_seconds, info);
}
std::pair<WifiStatus, sp<IWifiIface>> WifiRttController::getBoundIfaceInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), bound_iface_};
}
WifiStatus WifiRttController::registerEventCallbackInternal(
const sp<V1_0::IWifiRttControllerEventCallback>& /* callback */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiRttController::rangeRequestInternal(
uint32_t /* cmd_id */, const std::vector<V1_0::RttConfig>& /* rtt_configs */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiRttController::rangeCancelInternal(
uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs) {
std::vector<std::array<uint8_t, 6>> legacy_addrs;
for (const auto& addr : addrs) {
legacy_addrs.push_back(addr);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id, legacy_addrs);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_0::RttCapabilities> WifiRttController::getCapabilitiesInternal() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
WifiStatus WifiRttController::setLciInternal(uint32_t cmd_id, const RttLciInformation& lci) {
legacy_hal::wifi_lci_information legacy_lci;
if (!hidl_struct_util::convertHidlRttLciInformationToLegacy(lci, &legacy_lci)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiRttController::setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr) {
legacy_hal::wifi_lcr_information legacy_lcr;
if (!hidl_struct_util::convertHidlRttLcrInformationToLegacy(lcr, &legacy_lcr)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_0::RttResponder> WifiRttController::getResponderInfoInternal() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
WifiStatus WifiRttController::enableResponderInternal(
uint32_t /* cmd_id */, const V1_0::WifiChannelInfo& /* channel_hint */,
uint32_t /* max_duration_seconds */, const V1_0::RttResponder& /* info */) {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED)};
}
WifiStatus WifiRttController::disableResponderInternal(uint32_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiRttController::registerEventCallbackInternal_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& /* callback */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiRttController::rangeRequestInternal_1_4(
uint32_t /* cmd_id */, const std::vector<V1_4::RttConfig>& /* rtt_configs */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
std::pair<WifiStatus, V1_4::RttCapabilities> WifiRttController::getCapabilitiesInternal_1_4() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_4::RttResponder> WifiRttController::getResponderInfoInternal_1_4() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
WifiStatus WifiRttController::enableResponderInternal_1_4(
uint32_t /* cmd_id */, const V1_0::WifiChannelInfo& /* channel_hint */,
uint32_t /* max_duration_seconds */, const V1_4::RttResponder& /* info */) {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED)};
}
WifiStatus WifiRttController::registerEventCallbackInternal_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback) {
// TODO(b/31632518): remove the callback when the client is destroyed
event_callbacks_.emplace_back(callback);
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus WifiRttController::rangeRequestInternal_1_6(
uint32_t cmd_id, const std::vector<V1_6::RttConfig>& rtt_configs) {
std::vector<legacy_hal::wifi_rtt_config> legacy_configs;
if (!hidl_struct_util::convertHidlVectorOfRttConfigToLegacy(rtt_configs, &legacy_configs)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
android::wp<WifiRttController> weak_ptr_this(this);
const auto& on_results_callback =
[weak_ptr_this](legacy_hal::wifi_request_id id,
const std::vector<const legacy_hal::wifi_rtt_result*>& 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<V1_6::RttResult> hidl_results;
if (!hidl_struct_util::convertLegacyVectorOfRttResultToHidl(results,
&hidl_results)) {
LOG(ERROR) << "Failed to convert rtt results to HIDL structs";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onResults_1_6(id, hidl_results).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequest(
ifname_, cmd_id, legacy_configs, on_results_callback);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_6::RttCapabilities> WifiRttController::getCapabilitiesInternal_1_6() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_rtt_capabilities legacy_caps;
std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRttCapabilities(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
V1_6::RttCapabilities hidl_caps;
if (!hidl_struct_util::convertLegacyRttCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
}
std::pair<WifiStatus, V1_6::RttResponder> WifiRttController::getResponderInfoInternal_1_6() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_rtt_responder legacy_responder;
std::tie(legacy_status, legacy_responder) = legacy_hal_.lock()->getRttResponderInfo(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
V1_6::RttResponder hidl_responder;
if (!hidl_struct_util::convertLegacyRttResponderToHidl(legacy_responder, &hidl_responder)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_responder};
}
WifiStatus WifiRttController::enableResponderInternal_1_6(uint32_t cmd_id,
const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_6::RttResponder& info) {
legacy_hal::wifi_channel_info legacy_channel_info;
if (!hidl_struct_util::convertHidlWifiChannelInfoToLegacy(channel_hint, &legacy_channel_info)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_rtt_responder legacy_responder;
if (!hidl_struct_util::convertHidlRttResponderToLegacy(info, &legacy_responder)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableRttResponder(
ifname_, cmd_id, legacy_channel_info, max_duration_seconds, legacy_responder);
return createWifiStatusFromLegacyError(legacy_status);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

138
wifi/1.6/default/wifi_rtt_controller.h
View File

@@ -1,138 +0,0 @@
/*
* 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.
*/
#ifndef WIFI_RTT_CONTROLLER_H_
#define WIFI_RTT_CONTROLLER_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.0/IWifiIface.h>
#include <android/hardware/wifi/1.6/IWifiRttController.h>
#include <android/hardware/wifi/1.6/IWifiRttControllerEventCallback.h>
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
/**
* HIDL interface object used to control all RTT operations.
*/
class WifiRttController : public V1_6::IWifiRttController {
public:
WifiRttController(const std::string& iface_name, const sp<IWifiIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::vector<sp<V1_6::IWifiRttControllerEventCallback>> getEventCallbacks();
std::string getIfaceName();
// HIDL methods exposed.
Return<void> getBoundIface(getBoundIface_cb hidl_status_cb) override;
Return<void> registerEventCallback(const sp<V1_0::IWifiRttControllerEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> rangeRequest(uint32_t cmd_id, const hidl_vec<V1_0::RttConfig>& rtt_configs,
rangeRequest_cb hidl_status_cb) override;
Return<void> rangeCancel(uint32_t cmd_id, const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
rangeCancel_cb hidl_status_cb) override;
Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
Return<void> setLci(uint32_t cmd_id, const RttLciInformation& lci,
setLci_cb hidl_status_cb) override;
Return<void> setLcr(uint32_t cmd_id, const RttLcrInformation& lcr,
setLcr_cb hidl_status_cb) override;
Return<void> getResponderInfo(getResponderInfo_cb hidl_status_cb) override;
Return<void> enableResponder(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_0::RttResponder& info,
enableResponder_cb hidl_status_cb) override;
Return<void> disableResponder(uint32_t cmd_id, disableResponder_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_4_cb hidl_status_cb) override;
Return<void> rangeRequest_1_4(uint32_t cmd_id, const hidl_vec<V1_4::RttConfig>& rtt_configs,
rangeRequest_1_4_cb hidl_status_cb) override;
Return<void> getCapabilities_1_4(getCapabilities_1_4_cb hidl_status_cb) override;
Return<void> getResponderInfo_1_4(getResponderInfo_1_4_cb hidl_status_cb) override;
Return<void> enableResponder_1_4(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_4::RttResponder& info,
enableResponder_1_4_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_6_cb hidl_status_cb) override;
Return<void> rangeRequest_1_6(uint32_t cmd_id, const hidl_vec<V1_6::RttConfig>& rtt_configs,
rangeRequest_1_6_cb hidl_status_cb) override;
Return<void> getCapabilities_1_6(getCapabilities_1_6_cb hidl_status_cb) override;
Return<void> getResponderInfo_1_6(getResponderInfo_1_6_cb hidl_status_cb) override;
Return<void> enableResponder_1_6(uint32_t cmd_id, const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_6::RttResponder& info,
enableResponder_1_6_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, sp<IWifiIface>> getBoundIfaceInternal();
WifiStatus registerEventCallbackInternal(
const sp<V1_0::IWifiRttControllerEventCallback>& callback);
WifiStatus rangeRequestInternal(uint32_t cmd_id,
const std::vector<V1_0::RttConfig>& rtt_configs);
WifiStatus rangeCancelInternal(uint32_t cmd_id,
const std::vector<hidl_array<uint8_t, 6>>& addrs);
std::pair<WifiStatus, V1_0::RttCapabilities> getCapabilitiesInternal();
WifiStatus setLciInternal(uint32_t cmd_id, const RttLciInformation& lci);
WifiStatus setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr);
std::pair<WifiStatus, V1_0::RttResponder> getResponderInfoInternal();
WifiStatus enableResponderInternal(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_0::RttResponder& info);
WifiStatus disableResponderInternal(uint32_t cmd_id);
WifiStatus registerEventCallbackInternal_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& callback);
WifiStatus rangeRequestInternal_1_4(uint32_t cmd_id,
const std::vector<V1_4::RttConfig>& rtt_configs);
std::pair<WifiStatus, V1_4::RttCapabilities> getCapabilitiesInternal_1_4();
std::pair<WifiStatus, V1_4::RttResponder> getResponderInfoInternal_1_4();
WifiStatus enableResponderInternal_1_4(uint32_t cmd_id,
const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_4::RttResponder& info);
WifiStatus registerEventCallbackInternal_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback);
WifiStatus rangeRequestInternal_1_6(uint32_t cmd_id,
const std::vector<V1_6::RttConfig>& rtt_configs);
std::pair<WifiStatus, V1_6::RttCapabilities> getCapabilitiesInternal_1_6();
std::pair<WifiStatus, V1_6::RttResponder> getResponderInfoInternal_1_6();
WifiStatus enableResponderInternal_1_6(uint32_t cmd_id,
const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_6::RttResponder& info);
std::string ifname_;
sp<IWifiIface> bound_iface_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::vector<sp<V1_6::IWifiRttControllerEventCallback>> event_callbacks_;
bool is_valid_;
DISALLOW_COPY_AND_ASSIGN(WifiRttController);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_RTT_CONTROLLER_H_

592
wifi/1.6/default/wifi_sta_iface.cpp
View File

@@ -1,592 +0,0 @@
/*
* 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_6 {
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(
V1_0::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::getLinkLayerStats_1_5(getLinkLayerStats_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getLinkLayerStatsInternal_1_5, hidl_status_cb);
}
Return<void> WifiStaIface::getLinkLayerStats_1_6(getLinkLayerStats_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getLinkLayerStatsInternal_1_6, 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);
}
Return<void> WifiStaIface::setScanMode(bool enable, setScanMode_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::setScanModeInternal, hidl_status_cb, enable);
}
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;
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 {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(V1_0::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() {
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_5::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_5() {
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_6::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_6() {
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_6::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 */) {
// deprecated.
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
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 = 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 {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), mac};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), mac};
}
WifiStatus WifiStaIface::setScanModeInternal(bool enable) {
// OEM's need to implement this on their devices if needed.
LOG(WARNING) << "setScanModeInternal(" << enable << ") not supported";
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

157
wifi/1.6/default/wifi_sta_iface.h
View File

@@ -1,157 +0,0 @@
/*
* 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.
*/
#ifndef WIFI_STA_IFACE_H_
#define WIFI_STA_IFACE_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.0/IWifiStaIfaceEventCallback.h>
#include <android/hardware/wifi/1.6/IWifiStaIface.h>
#include "hidl_callback_util.h"
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
/**
* HIDL interface object used to control a STA Iface instance.
*/
class WifiStaIface : public V1_6::IWifiStaIface {
public:
WifiStaIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::set<sp<IWifiStaIfaceEventCallback>> getEventCallbacks();
std::string getName();
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
Return<void> registerEventCallback(const sp<IWifiStaIfaceEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
Return<void> getApfPacketFilterCapabilities(
getApfPacketFilterCapabilities_cb hidl_status_cb) override;
Return<void> installApfPacketFilter(uint32_t cmd_id, const hidl_vec<uint8_t>& program,
installApfPacketFilter_cb hidl_status_cb) override;
Return<void> readApfPacketFilterData(readApfPacketFilterData_cb hidl_status_cb) override;
Return<void> getBackgroundScanCapabilities(
getBackgroundScanCapabilities_cb hidl_status_cb) override;
Return<void> getValidFrequenciesForBand(V1_0::WifiBand band,
getValidFrequenciesForBand_cb hidl_status_cb) override;
Return<void> startBackgroundScan(uint32_t cmd_id, const StaBackgroundScanParameters& params,
startBackgroundScan_cb hidl_status_cb) override;
Return<void> stopBackgroundScan(uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) override;
Return<void> enableLinkLayerStatsCollection(
bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) override;
Return<void> disableLinkLayerStatsCollection(
disableLinkLayerStatsCollection_cb hidl_status_cb) override;
Return<void> getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb) override;
Return<void> getLinkLayerStats_1_3(getLinkLayerStats_1_3_cb hidl_status_cb) override;
Return<void> getLinkLayerStats_1_5(getLinkLayerStats_1_5_cb hidl_status_cb) override;
Return<void> getLinkLayerStats_1_6(getLinkLayerStats_1_6_cb hidl_status_cb) override;
Return<void> startRssiMonitoring(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi,
startRssiMonitoring_cb hidl_status_cb) override;
Return<void> stopRssiMonitoring(uint32_t cmd_id, stopRssiMonitoring_cb hidl_status_cb) override;
Return<void> getRoamingCapabilities(getRoamingCapabilities_cb hidl_status_cb) override;
Return<void> configureRoaming(const StaRoamingConfig& config,
configureRoaming_cb hidl_status_cb) override;
Return<void> setRoamingState(StaRoamingState state, setRoamingState_cb hidl_status_cb) override;
Return<void> enableNdOffload(bool enable, enableNdOffload_cb hidl_status_cb) override;
Return<void> 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) override;
Return<void> stopSendingKeepAlivePackets(
uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) override;
Return<void> setScanningMacOui(const hidl_array<uint8_t, 3>& oui,
setScanningMacOui_cb hidl_status_cb) override;
Return<void> startDebugPacketFateMonitoring(
startDebugPacketFateMonitoring_cb hidl_status_cb) override;
Return<void> getDebugTxPacketFates(getDebugTxPacketFates_cb hidl_status_cb) override;
Return<void> getDebugRxPacketFates(getDebugRxPacketFates_cb hidl_status_cb) override;
Return<void> setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) override;
Return<void> getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) override;
Return<void> setScanMode(bool enable, setScanMode_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
WifiStatus registerEventCallbackInternal(const sp<IWifiStaIfaceEventCallback>& callback);
std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
std::pair<WifiStatus, StaApfPacketFilterCapabilities> getApfPacketFilterCapabilitiesInternal();
WifiStatus installApfPacketFilterInternal(uint32_t cmd_id, const std::vector<uint8_t>& program);
std::pair<WifiStatus, std::vector<uint8_t>> readApfPacketFilterDataInternal();
std::pair<WifiStatus, StaBackgroundScanCapabilities> getBackgroundScanCapabilitiesInternal();
std::pair<WifiStatus, std::vector<WifiChannelInMhz>> getValidFrequenciesForBandInternal(
V1_0::WifiBand band);
WifiStatus startBackgroundScanInternal(uint32_t cmd_id,
const StaBackgroundScanParameters& params);
WifiStatus stopBackgroundScanInternal(uint32_t cmd_id);
WifiStatus enableLinkLayerStatsCollectionInternal(bool debug);
WifiStatus disableLinkLayerStatsCollectionInternal();
std::pair<WifiStatus, V1_0::StaLinkLayerStats> getLinkLayerStatsInternal();
std::pair<WifiStatus, V1_3::StaLinkLayerStats> getLinkLayerStatsInternal_1_3();
std::pair<WifiStatus, V1_5::StaLinkLayerStats> getLinkLayerStatsInternal_1_5();
std::pair<WifiStatus, V1_6::StaLinkLayerStats> getLinkLayerStatsInternal_1_6();
WifiStatus startRssiMonitoringInternal(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi);
WifiStatus stopRssiMonitoringInternal(uint32_t cmd_id);
std::pair<WifiStatus, StaRoamingCapabilities> getRoamingCapabilitiesInternal();
WifiStatus configureRoamingInternal(const StaRoamingConfig& config);
WifiStatus setRoamingStateInternal(StaRoamingState state);
WifiStatus enableNdOffloadInternal(bool enable);
WifiStatus 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);
WifiStatus stopSendingKeepAlivePacketsInternal(uint32_t cmd_id);
WifiStatus setScanningMacOuiInternal(const std::array<uint8_t, 3>& oui);
WifiStatus startDebugPacketFateMonitoringInternal();
std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>> getDebugTxPacketFatesInternal();
std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>> getDebugRxPacketFatesInternal();
WifiStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
std::pair<WifiStatus, std::array<uint8_t, 6>> getFactoryMacAddressInternal();
WifiStatus setScanModeInternal(bool enable);
std::string ifname_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
hidl_callback_util::HidlCallbackHandler<IWifiStaIfaceEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(WifiStaIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_STA_IFACE_H_

84
wifi/1.6/default/Android.bp → wifi/aidl/default/Android.bp
View File

@@ -1,4 +1,4 @@
// Copyright (C) 2021 The Android Open Source Project
// 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.
@@ -36,7 +36,7 @@ soong_config_module_type {
}
wifi_hal_cc_defaults {
name: "android.hardware.wifi@1.0-service-cppflags-defaults",
name: "android.hardware.wifi-service-cppflags-defaults",
soong_config_variables: {
hidl_feature_aware: {
cppflags: ["-DWIFI_HIDL_FEATURE_AWARE"],
@@ -60,8 +60,8 @@ wifi_hal_cc_defaults {
}
cc_library_static {
name: "android.hardware.wifi@1.0-service-lib",
defaults: ["android.hardware.wifi@1.0-service-cppflags-defaults"],
name: "android.hardware.wifi-service-lib",
defaults: ["android.hardware.wifi-service-cppflags-defaults"],
proprietary: true,
compile_multilib: "first",
cppflags: [
@@ -72,8 +72,8 @@ cc_library_static {
// Allow implicit fallthroughs in wifi_legacy_hal.cpp until they are fixed.
cflags: ["-Wno-error=implicit-fallthrough"],
srcs: [
"hidl_struct_util.cpp",
"hidl_sync_util.cpp",
"aidl_struct_util.cpp",
"aidl_sync_util.cpp",
"ringbuffer.cpp",
"wifi.cpp",
"wifi_ap_iface.cpp",
@@ -93,29 +93,23 @@ cc_library_static {
shared_libs: [
"libbase",
"libbinder_ndk",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
"libxml2",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
"android.hardware.wifi-V1-ndk",
],
export_include_dirs: ["."],
}
cc_binary {
name: "android.hardware.wifi@1.0-service",
vintf_fragments: ["android.hardware.wifi@1.0-service.xml"],
name: "android.hardware.wifi-service",
vintf_fragments: ["android.hardware.wifi-service.xml"],
relative_install_path: "hw",
proprietary: true,
cppflags: [
@@ -126,30 +120,24 @@ cc_binary {
srcs: ["service.cpp"],
shared_libs: [
"libbase",
"libbinder_ndk",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
"libxml2",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
"android.hardware.wifi-V1-ndk",
],
static_libs: ["android.hardware.wifi@1.0-service-lib"],
init_rc: ["android.hardware.wifi@1.0-service.rc"],
static_libs: ["android.hardware.wifi-service-lib"],
init_rc: ["android.hardware.wifi-service.rc"],
}
cc_binary {
name: "android.hardware.wifi@1.0-service-lazy",
vintf_fragments: ["android.hardware.wifi@1.0-service.xml"],
overrides: ["android.hardware.wifi@1.0-service"],
name: "android.hardware.wifi-service-lazy",
vintf_fragments: ["android.hardware.wifi-service.xml"],
overrides: ["android.hardware.wifi-service"],
cflags: ["-DLAZY_SERVICE"],
relative_install_path: "hw",
proprietary: true,
@@ -161,28 +149,22 @@ cc_binary {
srcs: ["service.cpp"],
shared_libs: [
"libbase",
"libbinder_ndk",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
"libxml2",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
"android.hardware.wifi-V1-ndk",
],
static_libs: ["android.hardware.wifi@1.0-service-lib"],
init_rc: ["android.hardware.wifi@1.0-service-lazy.rc"],
static_libs: ["android.hardware.wifi-service-lib"],
init_rc: ["android.hardware.wifi-service-lazy.rc"],
}
cc_test {
name: "android.hardware.wifi@1.0-service-tests",
name: "android.hardware.wifi-service-tests",
proprietary: true,
compile_multilib: "first",
cppflags: [
@@ -191,7 +173,7 @@ cc_test {
"-Wextra",
],
srcs: [
"tests/hidl_struct_util_unit_tests.cpp",
"tests/aidl_struct_util_unit_tests.cpp",
"tests/main.cpp",
"tests/mock_interface_tool.cpp",
"tests/mock_wifi_feature_flags.cpp",
@@ -206,19 +188,13 @@ cc_test {
static_libs: [
"libgmock",
"libgtest",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
"android.hardware.wifi@1.0-service-lib",
"android.hardware.wifi-V1-ndk",
"android.hardware.wifi-service-lib",
],
shared_libs: [
"libbase",
"libbinder_ndk",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
@@ -228,11 +204,11 @@ cc_test {
}
filegroup {
name: "default-android.hardware.wifi@1.0-service.rc",
srcs: ["android.hardware.wifi@1.0-service.rc"],
name: "default-android.hardware.wifi-service.rc",
srcs: ["android.hardware.wifi-service.rc"],
}
filegroup {
name: "default-android.hardware.wifi@1.0-service.xml",
srcs: ["android.hardware.wifi@1.0-service.xml"],
name: "default-android.hardware.wifi-service.xml",
srcs: ["android.hardware.wifi-service.xml"],
}

12
wifi/1.6/default/THREADING.README → wifi/aidl/default/THREADING.README
View File

@@ -1,7 +1,7 @@
Vendor HAL Threading Model
==========================
The vendor HAL service has two threads:
1. HIDL thread: This is the main thread which processes all the incoming HIDL
1. AIDL thread: This is the main thread which processes all the incoming AIDL
RPC's.
2. Legacy HAL event loop thread: This is the thread forked off for processing
the legacy HAL event loop (wifi_event_loop()). This thread is used to process
@@ -11,9 +11,9 @@ callbacks passed to the legacy HAL API's are invoked on this thread.
Synchronization Concerns
========================
wifi_legacy_hal.cpp has a bunch of global "C" style functions to handle the
legacy callbacks. Each of these "C" style function invokes a corresponding
legacy callbacks. Each of these "C" style functions invokes a corresponding
"std::function" version of the callback which does the actual processing.
The variables holding these "std::function" callbacks are reset from the HIDL
The variables holding these "std::function" callbacks are reset from the AIDL
thread when they are no longer used. For example: stopGscan() will reset the
corresponding "on_gscan_*" callback variables which were set when startGscan()
was invoked. This is not thread safe since these callback variables are
@@ -24,12 +24,12 @@ Synchronization Solution
Adding a global lock seems to be the most trivial solution to the problem.
a) All of the asynchronous "C" style callbacks will acquire the global lock
before invoking the corresponding "std::function" callback variables.
b) All of the HIDL methods will also acquire the global lock before processing
(in hidl_return_util::validateAndCall()).
b) All of the AIDL methods will also acquire the global lock before processing
(in aidl_return_util::validateAndCall()).
Note: It's important that we only acquire the global lock for asynchronous
callbacks, because there is no guarantee (or documentation to clarify) that the
synchronous callbacks are invoked on the same invocation thread. If that is not
the case in some implementation, we will end up deadlocking the system since the
HIDL thread would have acquired the global lock which is needed by the
AIDL thread would have acquired the global lock which is needed by the
synchronous callback executed on the legacy hal event loop thread.

140
wifi/aidl/default/aidl_callback_util.h Normal file
View File

@@ -0,0 +1,140 @@
/*
* 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.
*/
#ifndef AIDL_CALLBACK_UTIL_H_
#define AIDL_CALLBACK_UTIL_H_
#include <android-base/logging.h>
#include <set>
#include <unordered_map>
namespace {
std::unordered_map<void* /* callback */, void* /* handler */> callback_handler_map_;
}
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace aidl_callback_util {
// Provides a class to manage callbacks for the various AIDL interfaces and
// handle the death of the process hosting each callback.
template <typename CallbackType>
class AidlCallbackHandler {
public:
AidlCallbackHandler() {
death_handler_ = AIBinder_DeathRecipient_new(AidlCallbackHandler::onCallbackDeath);
}
~AidlCallbackHandler() { invalidate(); }
bool addCallback(const std::shared_ptr<CallbackType>& cb) {
void* cbPtr = reinterpret_cast<void*>(cb->asBinder().get());
const auto& cbPosition = findCbInSet(cbPtr);
if (cbPosition != cb_set_.end()) {
LOG(WARNING) << "Duplicate death notification registration";
return true;
}
if (AIBinder_linkToDeath(cb->asBinder().get(), death_handler_, cbPtr /* cookie */) !=
STATUS_OK) {
LOG(ERROR) << "Failed to register death notification";
return false;
}
callback_handler_map_[cbPtr] = reinterpret_cast<void*>(this);
cb_set_.insert(cb);
return true;
}
const std::set<std::shared_ptr<CallbackType>>& getCallbacks() { return cb_set_; }
void invalidate() {
for (auto cb : cb_set_) {
void* cookie = reinterpret_cast<void*>(cb->asBinder().get());
if (AIBinder_unlinkToDeath(cb->asBinder().get(), death_handler_, cookie) != STATUS_OK) {
LOG(ERROR) << "Failed to deregister death notification";
}
if (!removeCbFromHandlerMap(cookie)) {
LOG(ERROR) << "Failed to remove callback from handler map";
}
}
cb_set_.clear();
}
// Entry point for the death handling logic. AIBinder_DeathRecipient
// can only call a static function, so use the cookie to find the
// proper handler and route the request there.
static void onCallbackDeath(void* cookie) {
auto cbQuery = callback_handler_map_.find(cookie);
if (cbQuery == callback_handler_map_.end()) {
LOG(ERROR) << "Invalid death cookie received";
return;
}
AidlCallbackHandler* cbHandler = reinterpret_cast<AidlCallbackHandler*>(cbQuery->second);
if (cbHandler == nullptr) {
LOG(ERROR) << "Handler mapping contained an invalid handler";
return;
}
cbHandler->handleCallbackDeath(cbQuery->first);
}
private:
std::set<std::shared_ptr<CallbackType>> cb_set_;
AIBinder_DeathRecipient* death_handler_;
typename std::set<std::shared_ptr<CallbackType>>::iterator findCbInSet(void* cbPtr) {
const auto& cbPosition = std::find_if(
cb_set_.begin(), cb_set_.end(), [cbPtr](const std::shared_ptr<CallbackType>& p) {
return cbPtr == reinterpret_cast<void*>(p->asBinder().get());
});
return cbPosition;
}
bool removeCbFromHandlerMap(void* cbPtr) {
auto cbQuery = callback_handler_map_.find(cbPtr);
if (cbQuery != callback_handler_map_.end()) {
callback_handler_map_.erase(cbQuery);
return true;
}
return false;
}
void handleCallbackDeath(void* cbPtr) {
const auto& cbPosition = findCbInSet(cbPtr);
if (cbPosition == cb_set_.end()) {
LOG(ERROR) << "Unknown callback death notification received";
return;
}
cb_set_.erase(cbPosition);
if (!removeCbFromHandlerMap(cbPtr)) {
LOG(ERROR) << "Callback was not in callback handler map";
}
}
DISALLOW_COPY_AND_ASSIGN(AidlCallbackHandler);
};
} // namespace aidl_callback_util
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // AIDL_CALLBACK_UTIL_H_

85
wifi/aidl/default/aidl_return_util.h Normal file
View File

@@ -0,0 +1,85 @@
/*
* 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.
*/
#ifndef AIDL_RETURN_UTIL_H_
#define AIDL_RETURN_UTIL_H_
#include "aidl_sync_util.h"
#include "wifi_status_util.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace aidl_return_util {
using aidl::android::hardware::wifi::WifiStatusCode;
using aidl::android::hardware::wifi::aidl_sync_util::acquireGlobalLock;
/**
* These utility functions are used to invoke a method on the provided
* AIDL interface object.
* These functions checks if the provided AIDL interface object is valid.
* a) If valid, Invokes the corresponding internal implementation function of
* the AIDL method.
* b) If invalid, return without calling the internal implementation function.
*/
// Use for AIDL methods which return only an AIDL status.
template <typename ObjT, typename WorkFuncT, typename... Args>
::ndk::ScopedAStatus validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid,
WorkFuncT&& work, Args&&... args) {
const auto lock = acquireGlobalLock();
if (obj->isValid()) {
return (obj->*work)(std::forward<Args>(args)...);
} else {
return createWifiStatus(status_code_if_invalid);
}
}
// Use for AIDL methods which return only an AIDL status.
// This version passes the global lock acquired to the body of the method.
template <typename ObjT, typename WorkFuncT, typename... Args>
::ndk::ScopedAStatus validateAndCallWithLock(ObjT* obj, WifiStatusCode status_code_if_invalid,
WorkFuncT&& work, Args&&... args) {
auto lock = acquireGlobalLock();
if (obj->isValid()) {
return (obj->*work)(&lock, std::forward<Args>(args)...);
} else {
return createWifiStatus(status_code_if_invalid);
}
}
// Use for AIDL methods which have a return value along with the AIDL status
template <typename ObjT, typename WorkFuncT, typename ReturnT, typename... Args>
::ndk::ScopedAStatus validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid,
WorkFuncT&& work, ReturnT* ret_val, Args&&... args) {
const auto lock = acquireGlobalLock();
if (obj->isValid()) {
auto call_pair = (obj->*work)(std::forward<Args>(args)...);
*ret_val = call_pair.first;
return std::forward<::ndk::ScopedAStatus>(call_pair.second);
} else {
return ndk::ScopedAStatus::fromServiceSpecificError(
static_cast<int32_t>(status_code_if_invalid));
}
}
} // namespace aidl_return_util
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // AIDL_RETURN_UTIL_H_

2775
wifi/aidl/default/aidl_struct_util.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

180
wifi/aidl/default/aidl_struct_util.h Normal file
View File

@@ -0,0 +1,180 @@
/*
* 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.
*/
#ifndef AIDL_STRUCT_UTIL_H_
#define AIDL_STRUCT_UTIL_H_
#include <aidl/android/hardware/wifi/IWifiChip.h>
#include <aidl/android/hardware/wifi/IWifiChipEventCallback.h>
#include <aidl/android/hardware/wifi/NanBandIndex.h>
#include <aidl/android/hardware/wifi/WifiDebugRingBufferFlags.h>
#include <vector>
#include "wifi_legacy_hal.h"
/**
* This file contains a bunch of functions to convert structs from the legacy
* HAL to AIDL and vice versa.
*/
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace aidl_struct_util {
// Chip conversion methods.
bool convertLegacyFeaturesToAidlChipCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* aidl_caps);
bool convertLegacyDebugRingBufferStatusToAidl(
const legacy_hal::wifi_ring_buffer_status& legacy_status,
WifiDebugRingBufferStatus* aidl_status);
bool convertLegacyVectorOfDebugRingBufferStatusToAidl(
const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
std::vector<WifiDebugRingBufferStatus>* aidl_status_vec);
bool convertLegacyWakeReasonStatsToAidl(const legacy_hal::WakeReasonStats& legacy_stats,
WifiDebugHostWakeReasonStats* aidl_stats);
legacy_hal::wifi_power_scenario convertAidlTxPowerScenarioToLegacy(
IWifiChip::TxPowerScenario aidl_scenario);
legacy_hal::wifi_latency_mode convertAidlLatencyModeToLegacy(
IWifiChip::LatencyMode aidl_latency_mode);
bool convertLegacyWifiMacInfosToAidl(
const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
std::vector<IWifiChipEventCallback::RadioModeInfo>* aidl_radio_mode_infos);
legacy_hal::wifi_interface_type convertAidlIfaceTypeToLegacy(IfaceType aidl_interface_type);
legacy_hal::wifi_multi_sta_use_case convertAidlMultiStaUseCaseToLegacy(
IWifiChip::MultiStaUseCase use_case);
bool convertAidlCoexUnsafeChannelToLegacy(
const IWifiChip::CoexUnsafeChannel& aidl_unsafe_channel,
legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel);
bool convertAidlVectorOfCoexUnsafeChannelToLegacy(
const std::vector<IWifiChip::CoexUnsafeChannel>& aidl_unsafe_channels,
std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels);
bool convertLegacyRadioCombinationsMatrixToAidl(
legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
WifiRadioCombinationMatrix* aidl_matrix);
WifiBand convertLegacyMacBandToAidlWifiBand(uint32_t band);
WifiAntennaMode convertLegacyAntennaConfigurationToAidl(uint32_t antenna_cfg);
// STA iface conversion methods.
bool convertLegacyFeaturesToAidlStaCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* aidl_caps);
bool convertLegacyApfCapabilitiesToAidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
StaApfPacketFilterCapabilities* aidl_caps);
bool convertLegacyGscanCapabilitiesToAidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
StaBackgroundScanCapabilities* aidl_caps);
legacy_hal::wifi_band convertAidlWifiBandToLegacy(WifiBand band);
bool convertAidlGscanParamsToLegacy(const StaBackgroundScanParameters& aidl_scan_params,
legacy_hal::wifi_scan_cmd_params* legacy_scan_params);
// |has_ie_data| indicates whether or not the wifi_scan_result includes 802.11
// Information Elements (IEs)
bool convertLegacyGscanResultToAidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
bool has_ie_data, StaScanResult* aidl_scan_result);
// |cached_results| is assumed to not include IEs.
bool convertLegacyVectorOfCachedGscanResultsToAidl(
const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
std::vector<StaScanData>* aidl_scan_datas);
bool convertLegacyLinkLayerStatsToAidl(const legacy_hal::LinkLayerStats& legacy_stats,
StaLinkLayerStats* aidl_stats);
bool convertLegacyRoamingCapabilitiesToAidl(
const legacy_hal::wifi_roaming_capabilities& legacy_caps,
StaRoamingCapabilities* aidl_caps);
bool convertAidlRoamingConfigToLegacy(const StaRoamingConfig& aidl_config,
legacy_hal::wifi_roaming_config* legacy_config);
legacy_hal::fw_roaming_state_t convertAidlRoamingStateToLegacy(StaRoamingState state);
bool convertLegacyVectorOfDebugTxPacketFateToAidl(
const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
std::vector<WifiDebugTxPacketFateReport>* aidl_fates);
bool convertLegacyVectorOfDebugRxPacketFateToAidl(
const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
std::vector<WifiDebugRxPacketFateReport>* aidl_fates);
// NAN iface conversion methods.
void convertToNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
NanStatus* nanStatus);
bool convertAidlNanEnableRequestToLegacy(const NanEnableRequest& aidl_request1,
const NanConfigRequestSupplemental& aidl_request2,
legacy_hal::NanEnableRequest* legacy_request);
bool convertAidlNanConfigRequestToLegacy(const NanConfigRequest& aidl_request1,
const NanConfigRequestSupplemental& aidl_request2,
legacy_hal::NanConfigRequest* legacy_request);
bool convertAidlNanPublishRequestToLegacy(const NanPublishRequest& aidl_request,
legacy_hal::NanPublishRequest* legacy_request);
bool convertAidlNanSubscribeRequestToLegacy(const NanSubscribeRequest& aidl_request,
legacy_hal::NanSubscribeRequest* legacy_request);
bool convertAidlNanTransmitFollowupRequestToLegacy(
const NanTransmitFollowupRequest& aidl_request,
legacy_hal::NanTransmitFollowupRequest* legacy_request);
bool convertAidlNanDataPathInitiatorRequestToLegacy(
const NanInitiateDataPathRequest& aidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request);
bool convertAidlNanDataPathIndicationResponseToLegacy(
const NanRespondToDataPathIndicationRequest& aidl_response,
legacy_hal::NanDataPathIndicationResponse* legacy_response);
bool convertLegacyNanResponseHeaderToAidl(const legacy_hal::NanResponseMsg& legacy_response,
NanStatus* nanStatus);
bool convertLegacyNanCapabilitiesResponseToAidl(const legacy_hal::NanCapabilities& legacy_response,
NanCapabilities* aidl_response);
bool convertLegacyNanMatchIndToAidl(const legacy_hal::NanMatchInd& legacy_ind,
NanMatchInd* aidl_ind);
bool convertLegacyNanFollowupIndToAidl(const legacy_hal::NanFollowupInd& legacy_ind,
NanFollowupReceivedInd* aidl_ind);
bool convertLegacyNanDataPathRequestIndToAidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
NanDataPathRequestInd* aidl_ind);
bool convertLegacyNanDataPathConfirmIndToAidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
NanDataPathConfirmInd* aidl_ind);
bool convertLegacyNanDataPathScheduleUpdateIndToAidl(
const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
NanDataPathScheduleUpdateInd* aidl_ind);
// RTT controller conversion methods.
bool convertAidlVectorOfRttConfigToLegacy(const std::vector<RttConfig>& aidl_configs,
std::vector<legacy_hal::wifi_rtt_config>* legacy_configs);
bool convertAidlRttLciInformationToLegacy(const RttLciInformation& aidl_info,
legacy_hal::wifi_lci_information* legacy_info);
bool convertAidlRttLcrInformationToLegacy(const RttLcrInformation& aidl_info,
legacy_hal::wifi_lcr_information* legacy_info);
bool convertAidlRttResponderToLegacy(const RttResponder& aidl_responder,
legacy_hal::wifi_rtt_responder* legacy_responder);
bool convertAidlWifiChannelInfoToLegacy(const WifiChannelInfo& aidl_info,
legacy_hal::wifi_channel_info* legacy_info);
bool convertLegacyRttResponderToAidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
RttResponder* aidl_responder);
bool convertLegacyRttCapabilitiesToAidl(
const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
RttCapabilities* aidl_capabilities);
bool convertLegacyVectorOfRttResultToAidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
std::vector<RttResult>* aidl_results);
uint32_t convertAidlWifiBandToLegacyMacBand(WifiBand band);
uint32_t convertAidlWifiIfaceModeToLegacy(uint32_t aidl_iface_mask);
uint32_t convertAidlUsableChannelFilterToLegacy(uint32_t aidl_filter_mask);
bool convertLegacyWifiUsableChannelsToAidl(
const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
std::vector<WifiUsableChannel>* aidl_usable_channels);
bool convertLegacyPeerInfoStatsToAidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
StaPeerInfo* aidl_peer_info_stats);
bool convertLegacyWifiRateInfoToAidl(const legacy_hal::wifi_rate& legacy_rate,
WifiRateInfo* aidl_rate);
} // namespace aidl_struct_util
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // AIDL_STRUCT_UTIL_H_

14
wifi/1.6/default/hidl_sync_util.cpp → wifi/aidl/default/aidl_sync_util.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -14,26 +14,24 @@
* limitations under the License.
*/
#include "hidl_sync_util.h"
#include "aidl_sync_util.h"
namespace {
std::recursive_mutex g_mutex;
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_sync_util {
namespace aidl_sync_util {
std::unique_lock<std::recursive_mutex> acquireGlobalLock() {
return std::unique_lock<std::recursive_mutex>{g_mutex};
}
} // namespace hidl_sync_util
} // namespace implementation
} // namespace V1_6
} // namespace aidl_sync_util
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

20
wifi/1.6/default/hidl_sync_util.h → wifi/aidl/default/aidl_sync_util.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -14,24 +14,22 @@
* limitations under the License.
*/
#ifndef HIDL_SYNC_UTIL_H_
#define HIDL_SYNC_UTIL_H_
#ifndef AIDL_SYNC_UTIL_H_
#define AIDL_SYNC_UTIL_H_
#include <mutex>
// Utility that provides a global lock to synchronize access between
// the HIDL thread and the legacy HAL's event loop.
// the AIDL thread and the legacy HAL's event loop.
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_sync_util {
namespace aidl_sync_util {
std::unique_lock<std::recursive_mutex> acquireGlobalLock();
} // namespace hidl_sync_util
} // namespace implementation
} // namespace V1_6
} // namespace aidl_sync_util
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_SYNC_UTIL_H_
} // namespace aidl
#endif // AIDL_SYNC_UTIL_H_

8
wifi/aidl/default/android.hardware.wifi-service-lazy.rc Normal file
View File

@@ -0,0 +1,8 @@
service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi-service-lazy
interface aidl android.hardware.wifi.IWifi/default
oneshot
disabled
class hal
capabilities NET_ADMIN NET_RAW SYS_MODULE
user wifi
group wifi gps

6
wifi/aidl/default/android.hardware.wifi-service.rc Normal file
View File

@@ -0,0 +1,6 @@
service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi-service
interface aidl android.hardware.wifi.IWifi/default
class hal
capabilities NET_ADMIN NET_RAW SYS_MODULE
user wifi
group wifi gps

6
wifi/aidl/default/android.hardware.wifi-service.xml Normal file
View File

@@ -0,0 +1,6 @@
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.wifi</name>
<fqname>IWifi/default</fqname>
</hal>
</manifest>

12
wifi/1.6/default/ringbuffer.cpp → wifi/aidl/default/ringbuffer.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018 The Android Open Source Project
* 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.
@@ -14,15 +14,14 @@
* limitations under the License.
*/
#include <android-base/logging.h>
#include "ringbuffer.h"
#include <android-base/logging.h>
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
Ringbuffer::Ringbuffer(size_t maxSize) : size_(0), maxSize_(maxSize) {}
@@ -57,8 +56,7 @@ void Ringbuffer::clear() {
size_ = 0;
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

8
wifi/1.6/default/ringbuffer.h → wifi/aidl/default/ringbuffer.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018 The Android Open Source Project
* 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.
@@ -20,11 +20,10 @@
#include <list>
#include <vector>
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
/**
* Ringbuffer object used to store debug data.
@@ -53,10 +52,9 @@ class Ringbuffer {
size_t maxSize_;
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // RINGBUFFER_H_

73
wifi/aidl/default/service.cpp Normal file
View File

@@ -0,0 +1,73 @@
/*
* 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 <android-base/logging.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <signal.h>
#include "wifi.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_legacy_hal_factory.h"
#include "wifi_mode_controller.h"
using aidl::android::hardware::wifi::feature_flags::WifiFeatureFlags;
using aidl::android::hardware::wifi::legacy_hal::WifiLegacyHal;
using aidl::android::hardware::wifi::legacy_hal::WifiLegacyHalFactory;
using aidl::android::hardware::wifi::mode_controller::WifiModeController;
#ifdef LAZY_SERVICE
const bool kLazyService = true;
#else
const bool kLazyService = false;
#endif
int main(int /*argc*/, char** argv) {
signal(SIGPIPE, SIG_IGN);
android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
LOG(INFO) << "Wifi Hal is booting up...";
// Prepare the RPC-serving thread pool. Allocate 1 thread in the pool,
// which our main thread will join below.
ABinderProcess_setThreadPoolMaxThreadCount(1);
const auto iface_tool = std::make_shared<::android::wifi_system::InterfaceTool>();
const auto legacy_hal_factory = std::make_shared<WifiLegacyHalFactory>(iface_tool);
// Setup binder service
std::shared_ptr<aidl::android::hardware::wifi::Wifi> service =
ndk::SharedRefBase::make<aidl::android::hardware::wifi::Wifi>(
iface_tool, legacy_hal_factory, std::make_shared<WifiModeController>(),
std::make_shared<WifiFeatureFlags>());
std::string instance =
std::string() + aidl::android::hardware::wifi::Wifi::descriptor + "/default";
if (kLazyService) {
auto result =
AServiceManager_registerLazyService(service->asBinder().get(), instance.c_str());
CHECK_EQ(result, STATUS_OK) << "Failed to register lazy wifi HAL";
} else {
auto result = AServiceManager_addService(service->asBinder().get(), instance.c_str());
CHECK_EQ(result, STATUS_OK) << "Failed to register wifi HAL";
}
ABinderProcess_startThreadPool();
LOG(INFO) << "Joining RPC thread pool";
ABinderProcess_joinThreadPool();
LOG(INFO) << "Wifi Hal is terminating...";
return 0;
}

245
wifi/1.6/default/tests/hidl_struct_util_unit_tests.cpp → wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017, The Android Open Source Project
* 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.
@@ -18,8 +18,7 @@
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN
#include "hidl_struct_util.h"
#include "aidl_struct_util.h"
using testing::Test;
@@ -31,17 +30,15 @@ constexpr uint32_t kIfaceChannel2 = 5;
constexpr char kIfaceName1[] = "wlan0";
constexpr char kIfaceName2[] = "wlan1";
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using ::android::hardware::wifi::V1_6::WifiChannelWidthInMhz;
class HidlStructUtilTest : public Test {};
class AidlStructUtilTest : public Test {};
TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithOneMac) {
TEST_F(AidlStructUtilTest, CanConvertLegacyWifiMacInfosToAidlWithOneMac) {
std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
legacy_hal::WifiMacInfo legacy_mac_info1 = {
.wlan_mac_id = kMacId1,
@@ -52,24 +49,24 @@ TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithOneMac) {
legacy_mac_info1.iface_infos.push_back(legacy_iface_info2);
legacy_mac_infos.push_back(legacy_mac_info1);
std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
&hidl_radio_mode_infos));
std::vector<IWifiChipEventCallback::RadioModeInfo> aidl_radio_mode_infos;
ASSERT_TRUE(aidl_struct_util::convertLegacyWifiMacInfosToAidl(legacy_mac_infos,
&aidl_radio_mode_infos));
ASSERT_EQ(1u, hidl_radio_mode_infos.size());
auto hidl_radio_mode_info1 = hidl_radio_mode_infos[0];
EXPECT_EQ(legacy_mac_info1.wlan_mac_id, hidl_radio_mode_info1.radioId);
EXPECT_EQ(V1_4::WifiBand::BAND_24GHZ_5GHZ, hidl_radio_mode_info1.bandInfo);
ASSERT_EQ(2u, hidl_radio_mode_info1.ifaceInfos.size());
auto hidl_iface_info1 = hidl_radio_mode_info1.ifaceInfos[0];
EXPECT_EQ(legacy_iface_info1.name, hidl_iface_info1.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info1.channel), hidl_iface_info1.channel);
auto hidl_iface_info2 = hidl_radio_mode_info1.ifaceInfos[1];
EXPECT_EQ(legacy_iface_info2.name, hidl_iface_info2.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
ASSERT_EQ(1u, aidl_radio_mode_infos.size());
auto aidl_radio_mode_info1 = aidl_radio_mode_infos[0];
EXPECT_EQ(legacy_mac_info1.wlan_mac_id, (uint32_t)aidl_radio_mode_info1.radioId);
EXPECT_EQ(WifiBand::BAND_24GHZ_5GHZ, aidl_radio_mode_info1.bandInfo);
ASSERT_EQ(2u, aidl_radio_mode_info1.ifaceInfos.size());
auto aidl_iface_info1 = aidl_radio_mode_info1.ifaceInfos[0];
EXPECT_EQ(legacy_iface_info1.name, aidl_iface_info1.name);
EXPECT_EQ(static_cast<int32_t>(legacy_iface_info1.channel), aidl_iface_info1.channel);
auto aidl_iface_info2 = aidl_radio_mode_info1.ifaceInfos[1];
EXPECT_EQ(legacy_iface_info2.name, aidl_iface_info2.name);
EXPECT_EQ(static_cast<int32_t>(legacy_iface_info2.channel), aidl_iface_info2.channel);
}
TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithTwoMac) {
TEST_F(AidlStructUtilTest, CanConvertLegacyWifiMacInfosToAidlWithTwoMac) {
std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
legacy_hal::WifiMacInfo legacy_mac_info1 = {.wlan_mac_id = kMacId1,
.mac_band = legacy_hal::WLAN_MAC_5_0_BAND};
@@ -82,40 +79,40 @@ TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithTwoMac) {
legacy_mac_info2.iface_infos.push_back(legacy_iface_info2);
legacy_mac_infos.push_back(legacy_mac_info2);
std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
&hidl_radio_mode_infos));
std::vector<IWifiChipEventCallback::RadioModeInfo> aidl_radio_mode_infos;
ASSERT_TRUE(aidl_struct_util::convertLegacyWifiMacInfosToAidl(legacy_mac_infos,
&aidl_radio_mode_infos));
ASSERT_EQ(2u, hidl_radio_mode_infos.size());
ASSERT_EQ(2u, aidl_radio_mode_infos.size());
// Find mac info 1.
const auto hidl_radio_mode_info1 =
std::find_if(hidl_radio_mode_infos.begin(), hidl_radio_mode_infos.end(),
[&legacy_mac_info1](const V1_4::IWifiChipEventCallback::RadioModeInfo& x) {
return x.radioId == legacy_mac_info1.wlan_mac_id;
const auto aidl_radio_mode_info1 =
std::find_if(aidl_radio_mode_infos.begin(), aidl_radio_mode_infos.end(),
[&legacy_mac_info1](const IWifiChipEventCallback::RadioModeInfo& x) {
return (uint32_t)x.radioId == legacy_mac_info1.wlan_mac_id;
});
ASSERT_NE(hidl_radio_mode_infos.end(), hidl_radio_mode_info1);
EXPECT_EQ(V1_4::WifiBand::BAND_5GHZ, hidl_radio_mode_info1->bandInfo);
ASSERT_EQ(1u, hidl_radio_mode_info1->ifaceInfos.size());
auto hidl_iface_info1 = hidl_radio_mode_info1->ifaceInfos[0];
EXPECT_EQ(legacy_iface_info1.name, hidl_iface_info1.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info1.channel), hidl_iface_info1.channel);
ASSERT_NE(aidl_radio_mode_infos.end(), aidl_radio_mode_info1);
EXPECT_EQ(WifiBand::BAND_5GHZ, aidl_radio_mode_info1->bandInfo);
ASSERT_EQ(1u, aidl_radio_mode_info1->ifaceInfos.size());
auto aidl_iface_info1 = aidl_radio_mode_info1->ifaceInfos[0];
EXPECT_EQ(legacy_iface_info1.name, aidl_iface_info1.name);
EXPECT_EQ(static_cast<int32_t>(legacy_iface_info1.channel), aidl_iface_info1.channel);
// Find mac info 2.
const auto hidl_radio_mode_info2 =
std::find_if(hidl_radio_mode_infos.begin(), hidl_radio_mode_infos.end(),
[&legacy_mac_info2](const V1_4::IWifiChipEventCallback::RadioModeInfo& x) {
return x.radioId == legacy_mac_info2.wlan_mac_id;
const auto aidl_radio_mode_info2 =
std::find_if(aidl_radio_mode_infos.begin(), aidl_radio_mode_infos.end(),
[&legacy_mac_info2](const IWifiChipEventCallback::RadioModeInfo& x) {
return (uint32_t)x.radioId == legacy_mac_info2.wlan_mac_id;
});
ASSERT_NE(hidl_radio_mode_infos.end(), hidl_radio_mode_info2);
EXPECT_EQ(V1_4::WifiBand::BAND_24GHZ, hidl_radio_mode_info2->bandInfo);
ASSERT_EQ(1u, hidl_radio_mode_info2->ifaceInfos.size());
auto hidl_iface_info2 = hidl_radio_mode_info2->ifaceInfos[0];
EXPECT_EQ(legacy_iface_info2.name, hidl_iface_info2.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
ASSERT_NE(aidl_radio_mode_infos.end(), aidl_radio_mode_info2);
EXPECT_EQ(WifiBand::BAND_24GHZ, aidl_radio_mode_info2->bandInfo);
ASSERT_EQ(1u, aidl_radio_mode_info2->ifaceInfos.size());
auto aidl_iface_info2 = aidl_radio_mode_info2->ifaceInfos[0];
EXPECT_EQ(legacy_iface_info2.name, aidl_iface_info2.name);
EXPECT_EQ(static_cast<int32_t>(legacy_iface_info2.channel), aidl_iface_info2.channel);
}
TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
TEST_F(AidlStructUtilTest, canConvertLegacyLinkLayerStatsToAidl) {
legacy_hal::LinkLayerStats legacy_stats{};
legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
@@ -216,77 +213,77 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
peer.rate_stats.push_back(rate_stat2);
}
V1_6::StaLinkLayerStats converted{};
hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats, &converted);
EXPECT_EQ(legacy_stats.iface.beacon_rx, converted.iface.V1_0.beaconRx);
EXPECT_EQ(legacy_stats.iface.rssi_mgmt, converted.iface.V1_0.avgRssiMgmt);
StaLinkLayerStats converted{};
aidl_struct_util::convertLegacyLinkLayerStatsToAidl(legacy_stats, &converted);
EXPECT_EQ(legacy_stats.iface.beacon_rx, (uint32_t)converted.iface.beaconRx);
EXPECT_EQ(legacy_stats.iface.rssi_mgmt, converted.iface.avgRssiMgmt);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu,
converted.iface.V1_0.wmeBePktStats.rxMpdu);
converted.iface.wmeBePktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu,
converted.iface.V1_0.wmeBePktStats.txMpdu);
converted.iface.wmeBePktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost,
converted.iface.V1_0.wmeBePktStats.lostMpdu);
converted.iface.wmeBePktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries,
converted.iface.V1_0.wmeBePktStats.retries);
converted.iface.wmeBePktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min,
converted.iface.wmeBeContentionTimeStats.contentionTimeMinInUsec);
(uint32_t)converted.iface.wmeBeContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max,
converted.iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec);
(uint32_t)converted.iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg,
converted.iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec);
(uint32_t)converted.iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples,
converted.iface.wmeBeContentionTimeStats.contentionNumSamples);
(uint32_t)converted.iface.wmeBeContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu,
converted.iface.V1_0.wmeBkPktStats.rxMpdu);
converted.iface.wmeBkPktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu,
converted.iface.V1_0.wmeBkPktStats.txMpdu);
converted.iface.wmeBkPktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost,
converted.iface.V1_0.wmeBkPktStats.lostMpdu);
converted.iface.wmeBkPktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries,
converted.iface.V1_0.wmeBkPktStats.retries);
converted.iface.wmeBkPktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min,
converted.iface.wmeBkContentionTimeStats.contentionTimeMinInUsec);
(uint32_t)converted.iface.wmeBkContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max,
converted.iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec);
(uint32_t)converted.iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg,
converted.iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec);
(uint32_t)converted.iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples,
converted.iface.wmeBkContentionTimeStats.contentionNumSamples);
(uint32_t)converted.iface.wmeBkContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu,
converted.iface.V1_0.wmeViPktStats.rxMpdu);
converted.iface.wmeViPktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu,
converted.iface.V1_0.wmeViPktStats.txMpdu);
converted.iface.wmeViPktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost,
converted.iface.V1_0.wmeViPktStats.lostMpdu);
converted.iface.wmeViPktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries,
converted.iface.V1_0.wmeViPktStats.retries);
converted.iface.wmeViPktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min,
converted.iface.wmeViContentionTimeStats.contentionTimeMinInUsec);
(uint32_t)converted.iface.wmeViContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max,
converted.iface.wmeViContentionTimeStats.contentionTimeMaxInUsec);
(uint32_t)converted.iface.wmeViContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg,
converted.iface.wmeViContentionTimeStats.contentionTimeAvgInUsec);
(uint32_t)converted.iface.wmeViContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples,
converted.iface.wmeViContentionTimeStats.contentionNumSamples);
(uint32_t)converted.iface.wmeViContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu,
converted.iface.V1_0.wmeVoPktStats.rxMpdu);
converted.iface.wmeVoPktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu,
converted.iface.V1_0.wmeVoPktStats.txMpdu);
converted.iface.wmeVoPktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost,
converted.iface.V1_0.wmeVoPktStats.lostMpdu);
converted.iface.wmeVoPktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries,
converted.iface.V1_0.wmeVoPktStats.retries);
converted.iface.wmeVoPktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min,
converted.iface.wmeVoContentionTimeStats.contentionTimeMinInUsec);
(uint32_t)converted.iface.wmeVoContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max,
converted.iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec);
(uint32_t)converted.iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg,
converted.iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec);
(uint32_t)converted.iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples,
converted.iface.wmeVoContentionTimeStats.contentionNumSamples);
(uint32_t)converted.iface.wmeVoContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.info.time_slicing_duty_cycle_percent,
converted.iface.timeSliceDutyCycleInPercent);
@@ -294,42 +291,43 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
EXPECT_EQ(legacy_stats.radios.size(), converted.radios.size());
for (size_t i = 0; i < legacy_stats.radios.size(); i++) {
EXPECT_EQ(legacy_stats.radios[i].stats.radio, converted.radios[i].radioId);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time, converted.radios[i].V1_0.onTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.tx_time, converted.radios[i].V1_0.txTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.rx_time, converted.radios[i].V1_0.rxTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time, (uint32_t)converted.radios[i].onTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.tx_time, (uint32_t)converted.radios[i].txTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.rx_time, (uint32_t)converted.radios[i].rxTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_scan,
converted.radios[i].V1_0.onTimeInMsForScan);
(uint32_t)converted.radios[i].onTimeInMsForScan);
EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels.size(),
converted.radios[i].V1_0.txTimeInMsPerLevel.size());
converted.radios[i].txTimeInMsPerLevel.size());
for (size_t j = 0; j < legacy_stats.radios[i].tx_time_per_levels.size(); j++) {
EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels[j],
converted.radios[i].V1_0.txTimeInMsPerLevel[j]);
(uint32_t)converted.radios[i].txTimeInMsPerLevel[j]);
}
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_nbd,
converted.radios[i].onTimeInMsForNanScan);
(uint32_t)converted.radios[i].onTimeInMsForNanScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_gscan,
converted.radios[i].onTimeInMsForBgScan);
(uint32_t)converted.radios[i].onTimeInMsForBgScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_roam_scan,
converted.radios[i].onTimeInMsForRoamScan);
(uint32_t)converted.radios[i].onTimeInMsForRoamScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_pno_scan,
converted.radios[i].onTimeInMsForPnoScan);
(uint32_t)converted.radios[i].onTimeInMsForPnoScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_hs20,
converted.radios[i].onTimeInMsForHs20Scan);
(uint32_t)converted.radios[i].onTimeInMsForHs20Scan);
EXPECT_EQ(legacy_stats.radios[i].channel_stats.size(),
converted.radios[i].channelStats.size());
for (size_t k = 0; k < legacy_stats.radios[i].channel_stats.size(); k++) {
auto& legacy_channel_st = legacy_stats.radios[i].channel_stats[k];
EXPECT_EQ(WifiChannelWidthInMhz::WIDTH_20,
converted.radios[i].channelStats[k].channel.width);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq),
EXPECT_EQ(legacy_channel_st.channel.center_freq,
converted.radios[i].channelStats[k].channel.centerFreq);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq0),
EXPECT_EQ(legacy_channel_st.channel.center_freq0,
converted.radios[i].channelStats[k].channel.centerFreq0);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq1),
EXPECT_EQ(legacy_channel_st.channel.center_freq1,
converted.radios[i].channelStats[k].channel.centerFreq1);
EXPECT_EQ(legacy_channel_st.cca_busy_time,
converted.radios[i].channelStats[k].ccaBusyTimeInMs);
EXPECT_EQ(legacy_channel_st.on_time, converted.radios[i].channelStats[k].onTimeInMs);
(uint32_t)converted.radios[i].channelStats[k].ccaBusyTimeInMs);
EXPECT_EQ(legacy_channel_st.on_time,
(uint32_t)converted.radios[i].channelStats[k].onTimeInMs);
}
}
@@ -347,35 +345,36 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.bw,
(uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.bw);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.rateMcsIdx,
converted.iface.peers[i].rateStats[j].rateInfo.rateMcsIdx);
(uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.rateMcsIdx);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].tx_mpdu,
converted.iface.peers[i].rateStats[j].txMpdu);
(uint32_t)converted.iface.peers[i].rateStats[j].txMpdu);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rx_mpdu,
converted.iface.peers[i].rateStats[j].rxMpdu);
(uint32_t)converted.iface.peers[i].rateStats[j].rxMpdu);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].mpdu_lost,
converted.iface.peers[i].rateStats[j].mpduLost);
(uint32_t)converted.iface.peers[i].rateStats[j].mpduLost);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].retries,
converted.iface.peers[i].rateStats[j].retries);
(uint32_t)converted.iface.peers[i].rateStats[j].retries);
}
}
}
TEST_F(HidlStructUtilTest, CanConvertLegacyFeaturesToHidl) {
using HidlChipCaps = V1_3::IWifiChip::ChipCapabilityMask;
TEST_F(AidlStructUtilTest, CanConvertLegacyFeaturesToAidl) {
using AidlChipCaps = IWifiChip::ChipCapabilityMask;
uint32_t hidle_caps;
uint32_t aidl_caps;
uint32_t legacy_feature_set = WIFI_FEATURE_D2D_RTT | WIFI_FEATURE_SET_LATENCY_MODE;
uint32_t legacy_logger_feature_set = legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED;
ASSERT_TRUE(hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
legacy_feature_set, legacy_logger_feature_set, &hidle_caps));
ASSERT_TRUE(aidl_struct_util::convertLegacyFeaturesToAidlChipCapabilities(
legacy_feature_set, legacy_logger_feature_set, &aidl_caps));
EXPECT_EQ(HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA |
HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS |
HidlChipCaps::DEBUG_ERROR_ALERTS | HidlChipCaps::D2D_RTT |
HidlChipCaps::SET_LATENCY_MODE | HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP,
hidle_caps);
EXPECT_EQ((uint32_t)AidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA |
(uint32_t)AidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS |
(uint32_t)AidlChipCaps::DEBUG_ERROR_ALERTS | (uint32_t)AidlChipCaps::D2D_RTT |
(uint32_t)AidlChipCaps::SET_LATENCY_MODE |
(uint32_t)AidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP,
aidl_caps);
}
void insertRadioCombination(legacy_hal::wifi_radio_combination* dst_radio_combination_ptr,
@@ -390,16 +389,16 @@ void verifyRadioCombination(WifiRadioCombination* radioCombination, size_t num_r
legacy_hal::wifi_radio_configuration* radio_configuration) {
EXPECT_EQ(num_radio_configurations, radioCombination->radioConfigurations.size());
for (size_t i = 0; i < num_radio_configurations; i++) {
EXPECT_EQ(hidl_struct_util::convertLegacyMacBandToHidlWifiBand(radio_configuration->band),
EXPECT_EQ(aidl_struct_util::convertLegacyMacBandToAidlWifiBand(radio_configuration->band),
radioCombination->radioConfigurations[i].bandInfo);
EXPECT_EQ(hidl_struct_util::convertLegacyAntennaConfigurationToHidl(
EXPECT_EQ(aidl_struct_util::convertLegacyAntennaConfigurationToAidl(
radio_configuration->antenna_cfg),
radioCombination->radioConfigurations[i].antennaMode);
radio_configuration++;
}
}
TEST_F(HidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToHidl) {
TEST_F(AidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToAidl) {
legacy_hal::wifi_radio_configuration radio_configurations_array1[] = {
{.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_1X1},
};
@@ -461,8 +460,8 @@ TEST_F(HidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToHidl) {
sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
radio_configurations_array3);
V1_6::WifiRadioCombinationMatrix converted_matrix{};
hidl_struct_util::convertLegacyRadioCombinationsMatrixToHidl(legacy_matrix, &converted_matrix);
WifiRadioCombinationMatrix converted_matrix{};
aidl_struct_util::convertLegacyRadioCombinationsMatrixToAidl(legacy_matrix, &converted_matrix);
// Verify the conversion
EXPECT_EQ(legacy_matrix->num_radio_combinations, converted_matrix.radioCombinations.size());
@@ -479,8 +478,8 @@ TEST_F(HidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToHidl) {
sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
radio_configurations_array3);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

2
wifi/1.6/default/tests/main.cpp → wifi/aidl/default/tests/main.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* 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.

3
wifi/1.6/default/tests/mock_interface_tool.cpp → wifi/aidl/default/tests/mock_interface_tool.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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.
@@ -17,7 +17,6 @@
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_interface_tool.h"
namespace android {

2
wifi/1.6/default/tests/mock_interface_tool.h → wifi/aidl/default/tests/mock_interface_tool.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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.

8
wifi/1.6/default/tests/mock_wifi_feature_flags.cpp → wifi/aidl/default/tests/mock_wifi_feature_flags.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* 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.
@@ -18,18 +18,16 @@
#include "mock_wifi_feature_flags.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
MockWifiFeatureFlags::MockWifiFeatureFlags() {}
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

11
wifi/1.6/default/tests/mock_wifi_feature_flags.h → wifi/aidl/default/tests/mock_wifi_feature_flags.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* 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.
@@ -18,30 +18,27 @@
#define MOCK_WIFI_FEATURE_FLAGS_H_
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "wifi_feature_flags.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
class MockWifiFeatureFlags : public WifiFeatureFlags {
public:
MockWifiFeatureFlags();
MOCK_METHOD1(getChipModes, std::vector<V1_6::IWifiChip::ChipMode>(bool is_primary));
MOCK_METHOD1(getChipModes, std::vector<IWifiChip::ChipMode>(bool is_primary));
MOCK_METHOD0(isApMacRandomizationDisabled, bool());
};
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // MOCK_WIFI_FEATURE_FLAGS_H_

15
wifi/1.6/default/tests/mock_wifi_iface_util.cpp → wifi/aidl/default/tests/mock_wifi_iface_util.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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.
@@ -18,22 +18,21 @@
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_wifi_iface_util.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
MockWifiIfaceUtil::MockWifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
MockWifiIfaceUtil::MockWifiIfaceUtil(
const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: WifiIfaceUtil(iface_tool, legacy_hal) {}
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

16
wifi/1.6/default/tests/mock_wifi_iface_util.h → wifi/aidl/default/tests/mock_wifi_iface_util.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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.
@@ -21,30 +21,30 @@
#include "wifi_iface_util.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
class MockWifiIfaceUtil : public WifiIfaceUtil {
class MockWifiIfaceUtil : public iface_util::WifiIfaceUtil {
public:
MockWifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
MockWifiIfaceUtil(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
MOCK_METHOD1(getFactoryMacAddress, std::array<uint8_t, 6>(const std::string&));
MOCK_METHOD2(setMacAddress, bool(const std::string&, const std::array<uint8_t, 6>&));
MOCK_METHOD0(getOrCreateRandomMacAddress, std::array<uint8_t, 6>());
MOCK_METHOD2(registerIfaceEventHandlers, void(const std::string&, IfaceEventHandlers));
MOCK_METHOD2(registerIfaceEventHandlers,
void(const std::string&, iface_util::IfaceEventHandlers));
MOCK_METHOD1(unregisterIfaceEventHandlers, void(const std::string&));
MOCK_METHOD2(setUpState, bool(const std::string&, bool));
MOCK_METHOD1(ifNameToIndex, unsigned(const std::string&));
};
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // MOCK_WIFI_IFACE_UTIL_H_

14
wifi/1.6/default/tests/mock_wifi_legacy_hal.cpp → wifi/aidl/default/tests/mock_wifi_legacy_hal.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* 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.
@@ -18,22 +18,20 @@
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
MockWifiLegacyHal::MockWifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary)
MockWifiLegacyHal::MockWifiLegacyHal(
const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary)
: WifiLegacyHal(iface_tool, fn, is_primary) {}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

10
wifi/1.6/default/tests/mock_wifi_legacy_hal.h → wifi/aidl/default/tests/mock_wifi_legacy_hal.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* 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.
@@ -21,16 +21,15 @@
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
class MockWifiLegacyHal : public WifiLegacyHal {
public:
MockWifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
MockWifiLegacyHal(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary);
MOCK_METHOD0(initialize, wifi_error());
MOCK_METHOD0(start, wifi_error());
@@ -62,10 +61,9 @@ class MockWifiLegacyHal : public WifiLegacyHal {
MOCK_METHOD1(getSupportedFeatureSet, std::pair<wifi_error, uint64_t>(const std::string&));
};
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // MOCK_WIFI_LEGACY_HAL_H_

9
wifi/1.6/default/tests/mock_wifi_mode_controller.cpp → wifi/aidl/default/tests/mock_wifi_mode_controller.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* 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.
@@ -21,17 +21,16 @@
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_wifi_mode_controller.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
MockWifiModeController::MockWifiModeController() : WifiModeController() {}
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

8
wifi/1.6/default/tests/mock_wifi_mode_controller.h → wifi/aidl/default/tests/mock_wifi_mode_controller.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* 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.
@@ -21,11 +21,10 @@
#include "wifi_mode_controller.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
class MockWifiModeController : public WifiModeController {
@@ -37,10 +36,9 @@ class MockWifiModeController : public WifiModeController {
MOCK_METHOD0(deinitialize, bool());
};
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // MOCK_WIFI_MODE_CONTROLLER_H_

9
wifi/1.6/default/tests/ringbuffer_unit_tests.cpp → wifi/aidl/default/tests/ringbuffer_unit_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018, The Android Open Source Project
* 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.
@@ -21,11 +21,10 @@
using testing::Return;
using testing::Test;
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
class RingbufferTest : public Test {
public:
@@ -90,8 +89,8 @@ TEST_F(RingbufferTest, OversizedAppendDoesNotDropExistingData) {
ASSERT_EQ(1u, buffer_.getData().size());
EXPECT_EQ(input, buffer_.getData().front());
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

6
wifi/1.6/default/tests/runtests.sh → wifi/aidl/default/tests/runtests.sh
View File

@@ -1,6 +1,6 @@
#!/usr/bin/env bash
# Copyright(C) 2017 The Android Open Source Project
# 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.
@@ -20,7 +20,7 @@ if [ -z $ANDROID_BUILD_TOP ]; then
fi
set -e
$ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode android.hardware.wifi@1.0-service-tests
$ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode android.hardware.wifi-service-tests
adb root
adb sync data
adb shell /data/nativetest64/vendor/android.hardware.wifi@1.0-service-tests/android.hardware.wifi@1.0-service-tests
adb shell /data/nativetest64/vendor/android.hardware.wifi-service-tests/android.hardware.wifi-service-tests

429
wifi/1.6/default/tests/wifi_chip_unit_tests.cpp → wifi/aidl/default/tests/wifi_chip_unit_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017, The Android Open Source Project
* 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.
@@ -19,7 +19,6 @@
#include <cutils/properties.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "wifi_chip.h"
#include "mock_interface_tool.h"
@@ -33,28 +32,38 @@ using testing::Return;
using testing::Test;
namespace {
using android::hardware::wifi::V1_0::ChipId;
constexpr ChipId kFakeChipId = 5;
constexpr int kFakeChipId = 5;
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
class WifiChipTest : public Test {
protected:
void setupV1IfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
{{{{IfaceConcurrencyType::STA}, 1}, {{IfaceConcurrencyType::P2P}, 1}}}
// 1 STA + 1 P2P
const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsSta =
{
{
{
{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P}, 1}
}
}
};
// 1 AP
const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsAp =
{
{
{
{{IfaceConcurrencyType::AP}, 1}
}
}
};
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsAp = {
{{{{IfaceConcurrencyType::AP}, 1}}}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
const std::vector<IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
{feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
};
@@ -64,14 +73,26 @@ class WifiChipTest : public Test {
void setupV1_AwareIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
// 1 STA + 1 of (P2P or NAN)
const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsSta =
{
{
{
{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
}
}
};
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsAp = {
{{{{IfaceConcurrencyType::AP}, 1}}}
// 1 AP
const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsAp =
{
{
{
{{IfaceConcurrencyType::AP}, 1}
}
}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
const std::vector<IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
{feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
};
@@ -81,11 +102,17 @@ class WifiChipTest : public Test {
void setupV1_AwareDisabledApIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
// 1 STA + 1 of (P2P or NAN)
const std::vector<IWifiChip::ChipConcurrencyCombination> combinationsSta =
{
{
{
{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
}
}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
const std::vector<IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV1Sta, combinationsSta}
};
// clang-format on
@@ -94,12 +121,23 @@ class WifiChipTest : public Test {
void setupV2_AwareIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
{{{{IfaceConcurrencyType::STA}, 1}, {{IfaceConcurrencyType::AP}, 1}}},
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
// (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
const std::vector<IWifiChip::ChipConcurrencyCombination> combinations =
{
{
{
{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::AP}, 1}
}
},
{
{
{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
}
}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
const std::vector<IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
@@ -108,11 +146,17 @@ class WifiChipTest : public Test {
void setupV2_AwareDisabledApIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
// 1 STA + 1 of (P2P or NAN)
const std::vector<IWifiChip::ChipConcurrencyCombination> combinations =
{
{
{
{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN_IFACE}, 1}
}
}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
const std::vector<IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
@@ -121,10 +165,17 @@ class WifiChipTest : public Test {
void setup_MultiIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
{{{{IfaceConcurrencyType::STA}, 3}, {{IfaceConcurrencyType::AP}, 1}}}
// 3 STA + 1 AP
const std::vector<IWifiChip::ChipConcurrencyCombination> combinations =
{
{
{
{{IfaceConcurrencyType::STA}, 3},
{{IfaceConcurrencyType::AP}, 1}
}
}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
const std::vector<IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
@@ -132,134 +183,93 @@ class WifiChipTest : public Test {
}
void assertNumberOfModes(uint32_t num_modes) {
chip_->getAvailableModes_1_6([num_modes](const WifiStatus& status,
const std::vector<WifiChip::ChipMode>& modes) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
// V2_Aware has 1 mode of operation.
ASSERT_EQ(num_modes, modes.size());
});
std::vector<IWifiChip::ChipMode> modes;
ASSERT_TRUE(chip_->getAvailableModes(&modes).isOk());
// V2_Aware has 1 mode of operation.
ASSERT_EQ(num_modes, modes.size());
}
void findModeAndConfigureForIfaceType(const IfaceConcurrencyType& type) {
// This should be aligned with kInvalidModeId in wifi_chip.cpp.
ChipModeId mode_id = UINT32_MAX;
chip_->getAvailableModes_1_6([&mode_id, &type](
const WifiStatus& status,
const std::vector<WifiChip::ChipMode>& modes) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
for (const auto& mode : modes) {
for (const auto& combination : mode.availableCombinations) {
for (const auto& limit : combination.limits) {
if (limit.types.end() !=
std::find(limit.types.begin(), limit.types.end(), type)) {
mode_id = mode.id;
}
// This should be aligned with kInvalidModeId in wifi_chip.cpp
int32_t mode_id = INT32_MAX;
std::vector<IWifiChip::ChipMode> modes;
ASSERT_TRUE(chip_->getAvailableModes(&modes).isOk());
for (const auto& mode : modes) {
for (const auto& combination : mode.availableCombinations) {
for (const auto& limit : combination.limits) {
if (limit.types.end() !=
std::find(limit.types.begin(), limit.types.end(), type)) {
mode_id = mode.id;
}
}
}
});
ASSERT_NE(UINT32_MAX, mode_id);
}
chip_->configureChip(mode_id, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
ASSERT_NE(INT32_MAX, mode_id);
ASSERT_TRUE(chip_->configureChip(mode_id).isOk());
}
// Returns an empty string on error.
std::string createIface(const IfaceType& type) {
std::string iface_name;
if (type == IfaceType::AP) {
chip_->createApIface(
[&iface_name](const WifiStatus& status, const sp<V1_0::IWifiApIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
} else if (type == IfaceType::NAN) {
chip_->createNanIface(
[&iface_name](const WifiStatus& status,
const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
std::shared_ptr<IWifiApIface> iface;
if (!chip_->createApIface(&iface).isOk()) {
return "";
}
EXPECT_NE(iface.get(), nullptr);
EXPECT_TRUE(iface->getName(&iface_name).isOk());
} else if (type == IfaceType::NAN_IFACE) {
std::shared_ptr<IWifiNanIface> iface;
if (!chip_->createNanIface(&iface).isOk()) {
return "";
}
EXPECT_NE(iface.get(), nullptr);
EXPECT_TRUE(iface->getName(&iface_name).isOk());
} else if (type == IfaceType::P2P) {
chip_->createP2pIface(
[&iface_name](const WifiStatus& status, const sp<IWifiP2pIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
std::shared_ptr<IWifiP2pIface> iface;
if (!chip_->createP2pIface(&iface).isOk()) {
return "";
}
EXPECT_NE(iface.get(), nullptr);
EXPECT_TRUE(iface->getName(&iface_name).isOk());
} else if (type == IfaceType::STA) {
chip_->createStaIface(
[&iface_name](const WifiStatus& status, const sp<V1_0::IWifiStaIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
std::shared_ptr<IWifiStaIface> iface;
if (!chip_->createStaIface(&iface).isOk()) {
return "";
}
EXPECT_NE(iface.get(), nullptr);
EXPECT_TRUE(iface->getName(&iface_name).isOk());
}
return iface_name;
}
void removeIface(const IfaceType& type, const std::string& iface_name) {
if (type == IfaceType::AP) {
chip_->removeApIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
} else if (type == IfaceType::NAN) {
chip_->removeNanIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
ASSERT_TRUE(chip_->removeApIface(iface_name).isOk());
} else if (type == IfaceType::NAN_IFACE) {
ASSERT_TRUE(chip_->removeNanIface(iface_name).isOk());
} else if (type == IfaceType::P2P) {
chip_->removeP2pIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
ASSERT_TRUE(chip_->removeP2pIface(iface_name).isOk());
} else if (type == IfaceType::STA) {
chip_->removeStaIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
ASSERT_TRUE(chip_->removeStaIface(iface_name).isOk());
}
}
bool createRttController() {
bool success = false;
chip_->createRttController_1_6(
NULL, [&success](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
success = true;
}
});
return success;
std::shared_ptr<IWifiRttController> rtt_controller;
auto status = chip_->createRttController(nullptr, &rtt_controller);
return status.isOk();
}
static void subsystemRestartHandler(const std::string& /*error*/) {}
sp<WifiChip> chip_;
ChipId chip_id_ = kFakeChipId;
std::shared_ptr<WifiChip> chip_;
int chip_id_ = kFakeChipId;
legacy_hal::wifi_hal_fn fake_func_table_;
std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<wifi_system::MockInterfaceTool>};
std::shared_ptr<NiceMock<::android::wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<::android::wifi_system::MockInterfaceTool>};
std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>> mode_controller_{
@@ -271,8 +281,8 @@ class WifiChipTest : public Test {
public:
void SetUp() override {
chip_ = new WifiChip(chip_id_, true, legacy_hal_, mode_controller_, iface_util_,
feature_flags_, subsystemRestartHandler);
chip_ = WifiChip::create(chip_id_, true, legacy_hal_, mode_controller_, iface_util_,
feature_flags_, subsystemRestartHandler);
EXPECT_CALL(*mode_controller_, changeFirmwareMode(testing::_))
.WillRepeatedly(testing::Return(true));
@@ -301,7 +311,7 @@ class WifiChipV1IfaceCombinationTest : public WifiChipTest {
setupV1IfaceCombination();
WifiChipTest::SetUp();
// V1 has 2 modes of operation.
assertNumberOfModes(2u);
assertNumberOfModes(2);
}
};
@@ -317,7 +327,7 @@ TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
@@ -348,7 +358,7 @@ TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
}
////////// V1 + Aware Iface Combinations ////////////
@@ -376,7 +386,7 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
@@ -393,37 +403,37 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2p_ShouldSucceed)
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2PNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
std::string p2p_iface_name = createIface(IfaceType::P2P);
ASSERT_FALSE(p2p_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
// After removing P2P iface, NAN iface creation should succeed.
removeIface(IfaceType::P2P, p2p_iface_name);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
std::string nan_iface_name = createIface(IfaceType::NAN_IFACE);
ASSERT_FALSE(nan_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
// After removing NAN iface, P2P iface creation should succeed.
removeIface(IfaceType::NAN, nan_iface_name);
removeIface(IfaceType::NAN_IFACE, nan_iface_name);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
@@ -444,7 +454,7 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
@@ -460,7 +470,7 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowApToSta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
const auto ap_iface_name = createIface(IfaceType::AP);
std::string ap_iface_name = createIface(IfaceType::AP);
ASSERT_FALSE(ap_iface_name.empty());
ASSERT_FALSE(createRttController());
@@ -475,9 +485,7 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
@@ -485,9 +493,7 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
}
////////// V2 + Aware Iface Combinations ////////////
@@ -515,7 +521,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateP2p_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateAp_ShouldSucceed) {
@@ -543,9 +549,9 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApSta_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_AfterStaApRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
const auto sta_iface_name = createIface(IfaceType::STA);
std::string sta_iface_name = createIface(IfaceType::STA);
ASSERT_FALSE(sta_iface_name.empty());
const auto ap_iface_name = createIface(IfaceType::AP);
std::string ap_iface_name = createIface(IfaceType::AP);
ASSERT_FALSE(ap_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::STA).empty());
@@ -565,44 +571,44 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2PNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
std::string p2p_iface_name = createIface(IfaceType::P2P);
ASSERT_FALSE(p2p_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
// After removing P2P iface, NAN iface creation should succeed.
removeIface(IfaceType::P2P, p2p_iface_name);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
std::string nan_iface_name = createIface(IfaceType::NAN_IFACE);
ASSERT_FALSE(nan_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
// After removing NAN iface, P2P iface creation should succeed.
removeIface(IfaceType::NAN, nan_iface_name);
removeIface(IfaceType::NAN_IFACE, nan_iface_name);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_FALSE(createIface(IfaceType::AP).empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApP2p_ShouldFail) {
@@ -614,31 +620,31 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApP2p_ShouldFail) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
std::string p2p_iface_name = createIface(IfaceType::P2P);
ASSERT_FALSE(p2p_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
ASSERT_TRUE(createIface(IfaceType::NAN_IFACE).empty());
// After removing P2P iface, NAN iface creation should succeed.
removeIface(IfaceType::P2P, p2p_iface_name);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
ASSERT_FALSE(createIface(IfaceType::NAN_IFACE).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
std::string nan_iface_name = createIface(IfaceType::NAN_IFACE);
ASSERT_FALSE(nan_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
// After removing NAN iface, P2P iface creation should succeed.
removeIface(IfaceType::NAN, nan_iface_name);
removeIface(IfaceType::NAN_IFACE, nan_iface_name);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_EnsureDifferentIfaceNames) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
const auto sta_iface_name = createIface(IfaceType::STA);
const auto ap_iface_name = createIface(IfaceType::AP);
std::string sta_iface_name = createIface(IfaceType::STA);
std::string ap_iface_name = createIface(IfaceType::AP);
ASSERT_FALSE(sta_iface_name.empty());
ASSERT_FALSE(ap_iface_name.empty());
ASSERT_NE(sta_iface_name, ap_iface_name);
@@ -667,9 +673,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
@@ -677,9 +681,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan1", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF).isOk());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveNanOnStaRemove) {
@@ -687,35 +689,29 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveNanOnStaRemove)
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
// Create NAN iface
ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
ASSERT_EQ(createIface(IfaceType::NAN_IFACE), "wlan0");
// We should have 1 nan iface.
chip_->getNanIfaceNames([](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
ASSERT_EQ(iface_names.size(), 1u);
ASSERT_EQ(iface_names[0], "wlan0");
});
// Retrieve the exact iface object.
sp<android::hardware::wifi::V1_0::IWifiNanIface> nan_iface;
chip_->getNanIface("wlan0",
[&nan_iface](const WifiStatus& status,
const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
ASSERT_NE(iface.get(), nullptr);
nan_iface = iface;
});
std::vector<std::string> iface_names;
ASSERT_TRUE(chip_->getNanIfaceNames(&iface_names).isOk());
ASSERT_EQ(iface_names.size(), 1u);
ASSERT_EQ(iface_names[0], "wlan0");
// Remove the STA iface.
// Retrieve the nan iface object.
std::shared_ptr<IWifiNanIface> nan_iface;
ASSERT_TRUE(chip_->getNanIface("wlan0", &nan_iface).isOk());
ASSERT_NE(nan_iface.get(), nullptr);
// Remove the STA iface. We should have 0 nan ifaces now.
removeIface(IfaceType::STA, "wlan0");
// We should have 0 nan iface now.
chip_->getNanIfaceNames([](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
ASSERT_EQ(iface_names.size(), 0u);
});
// Any operation on the nan iface object should return error now.
nan_iface->getName([](const WifiStatus& status, const std::string& /* iface_name */) {
ASSERT_EQ(WifiStatusCode::ERROR_WIFI_IFACE_INVALID, status.code);
});
ASSERT_TRUE(chip_->getNanIfaceNames(&iface_names).isOk());
ASSERT_EQ(iface_names.size(), 0u);
// Any operation on the nan iface object should now return an error.
std::string name;
auto status = nan_iface->getName(&name);
ASSERT_EQ(status.getServiceSpecificError(),
static_cast<int32_t>(WifiStatusCode::ERROR_WIFI_IFACE_INVALID));
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveRttControllerOnStaRemove) {
@@ -723,30 +719,25 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveRttControllerOnS
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
// Create RTT controller
sp<IWifiRttController> rtt_controller;
chip_->createRttController_1_6(
NULL, [&rtt_controller](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
rtt_controller = rtt;
}
});
std::shared_ptr<IWifiRttController> rtt_controller;
ASSERT_TRUE(chip_->createRttController(nullptr, &rtt_controller).isOk());
// Remove the STA iface.
removeIface(IfaceType::STA, "wlan0");
// Any operation on the rtt controller object should return error now.
rtt_controller->getBoundIface([](const WifiStatus& status, const sp<IWifiIface>& /* iface */) {
ASSERT_EQ(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, status.code);
});
// Any operation on the rtt controller object should now return an error.
std::shared_ptr<IWifiStaIface> bound_iface;
auto status = rtt_controller->getBoundIface(&bound_iface);
ASSERT_EQ(status.getServiceSpecificError(),
static_cast<int32_t>(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID));
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithSharedNanIface) {
property_set("wifi.aware.interface", nullptr);
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
removeIface(IfaceType::NAN, "wlan0");
ASSERT_EQ(createIface(IfaceType::NAN_IFACE), "wlan0");
removeIface(IfaceType::NAN_IFACE, "wlan0");
EXPECT_CALL(*iface_util_, setUpState(testing::_, testing::_)).Times(0);
}
@@ -756,10 +747,10 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithDedicatedNanIface) {
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*iface_util_, ifNameToIndex("aware0")).WillOnce(testing::Return(4));
EXPECT_CALL(*iface_util_, setUpState("aware0", true)).WillOnce(testing::Return(true));
ASSERT_EQ(createIface(IfaceType::NAN), "aware0");
ASSERT_EQ(createIface(IfaceType::NAN_IFACE), "aware0");
EXPECT_CALL(*iface_util_, setUpState("aware0", false)).WillOnce(testing::Return(true));
removeIface(IfaceType::NAN, "aware0");
removeIface(IfaceType::NAN_IFACE, "aware0");
}
////////// V1 Iface Combinations when AP creation is disabled //////////
@@ -857,8 +848,8 @@ TEST_F(WifiChip_MultiIfaceTest, CreateApStartsWithIdx1) {
ASSERT_EQ(createIface(IfaceType::STA), "wlan1");
ASSERT_EQ(createIface(IfaceType::STA), "wlan3");
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

14
wifi/1.6/default/tests/wifi_iface_util_unit_tests.cpp → wifi/aidl/default/tests/wifi_iface_util_unit_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019, The Android Open Source Project
* 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.
@@ -18,7 +18,6 @@
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN
#include "wifi_iface_util.h"
#include "mock_interface_tool.h"
@@ -38,16 +37,16 @@ bool isValidUnicastLocallyAssignedMacAddress(const std::array<uint8_t, 6>& mac_a
}
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
class WifiIfaceUtilTest : public Test {
protected:
std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<wifi_system::MockInterfaceTool>};
std::shared_ptr<NiceMock<::android::wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<::android::wifi_system::MockInterfaceTool>};
legacy_hal::wifi_hal_fn fake_func_table_;
std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
@@ -89,8 +88,7 @@ TEST_F(WifiIfaceUtilTest, IfaceEventHandlers_SetMacAddress) {
ASSERT_FALSE(callback_invoked);
}
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

168
wifi/aidl/default/tests/wifi_nan_iface_unit_tests.cpp Normal file
View File

@@ -0,0 +1,168 @@
/*
* 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 <android-base/logging.h>
#include <android-base/macros.h>
#include <cutils/properties.h>
#include <gmock/gmock.h>
#include "wifi_nan_iface.h"
#include "mock_interface_tool.h"
#include "mock_wifi_feature_flags.h"
#include "mock_wifi_iface_util.h"
#include "mock_wifi_legacy_hal.h"
using testing::NiceMock;
using testing::Return;
using testing::Test;
namespace {
constexpr char kIfaceName[] = "mockWlan0";
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
bool CaptureIfaceEventHandlers(const std::string& /* iface_name*/,
iface_util::IfaceEventHandlers in_iface_event_handlers,
iface_util::IfaceEventHandlers* out_iface_event_handlers) {
*out_iface_event_handlers = in_iface_event_handlers;
return true;
}
class MockNanIface : public WifiNanIface {
public:
MockNanIface(const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
: WifiNanIface(ifname, is_dedicated_iface, legacy_hal, iface_util) {}
static std::shared_ptr<MockNanIface> createMock(
const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) {
std::shared_ptr<MockNanIface> ptr = ndk::SharedRefBase::make<MockNanIface>(
ifname, is_dedicated_iface, legacy_hal, iface_util);
std::weak_ptr<MockNanIface> weak_ptr_this(ptr);
ptr->setWeakPtr(weak_ptr_this);
ptr->registerCallbackHandlers();
return ptr;
}
// Override getEventCallbacks() so that we can return a mocked callback object.
std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> getEventCallbacks() override {
return {callback_};
}
void setMockCallback(std::shared_ptr<IWifiNanIfaceEventCallback> cb) { callback_ = cb; }
private:
std::shared_ptr<IWifiNanIfaceEventCallback> callback_;
};
class MockNanIfaceEventCallback : public IWifiNanIfaceEventCallback {
public:
ndk::SpAIBinder asBinder() override { return ::ndk::SpAIBinder{}; }
bool isRemote() override { return false; }
::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override {
*_aidl_return = 1;
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override {
*_aidl_return = "some_hash";
return ndk::ScopedAStatus::ok();
}
MOCK_METHOD3(notifyCapabilitiesResponse,
ndk::ScopedAStatus(char16_t, const NanStatus&, const NanCapabilities&));
MOCK_METHOD2(notifyEnableResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD2(notifyConfigResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD2(notifyDisableResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD3(notifyStartPublishResponse,
ndk::ScopedAStatus(char16_t, const NanStatus&, int8_t));
MOCK_METHOD2(notifyStopPublishResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD3(notifyStartSubscribeResponse,
ndk::ScopedAStatus(char16_t, const NanStatus&, int8_t));
MOCK_METHOD2(notifyStopSubscribeResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD2(notifyTransmitFollowupResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD2(notifyCreateDataInterfaceResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD2(notifyDeleteDataInterfaceResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD3(notifyInitiateDataPathResponse,
ndk::ScopedAStatus(char16_t, const NanStatus&, int32_t));
MOCK_METHOD2(notifyRespondToDataPathIndicationResponse,
ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD2(notifyTerminateDataPathResponse, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD1(eventClusterEvent, ndk::ScopedAStatus(const NanClusterEventInd&));
MOCK_METHOD1(eventDisabled, ndk::ScopedAStatus(const NanStatus&));
MOCK_METHOD2(eventPublishTerminated, ndk::ScopedAStatus(int8_t, const NanStatus&));
MOCK_METHOD2(eventSubscribeTerminated, ndk::ScopedAStatus(int8_t, const NanStatus&));
MOCK_METHOD1(eventMatch, ndk::ScopedAStatus(const NanMatchInd&));
MOCK_METHOD2(eventMatchExpired, ndk::ScopedAStatus(int8_t, int32_t));
MOCK_METHOD1(eventFollowupReceived, ndk::ScopedAStatus(const NanFollowupReceivedInd&));
MOCK_METHOD2(eventTransmitFollowup, ndk::ScopedAStatus(char16_t, const NanStatus&));
MOCK_METHOD1(eventDataPathRequest, ndk::ScopedAStatus(const NanDataPathRequestInd&));
MOCK_METHOD1(eventDataPathConfirm, ndk::ScopedAStatus(const NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathTerminated, ndk::ScopedAStatus(int32_t));
MOCK_METHOD1(eventDataPathScheduleUpdate,
ndk::ScopedAStatus(const NanDataPathScheduleUpdateInd&));
};
class WifiNanIfaceTest : public Test {
protected:
legacy_hal::wifi_hal_fn fake_func_table_;
std::shared_ptr<NiceMock<::android::wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<::android::wifi_system::MockInterfaceTool>};
std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
};
TEST_F(WifiNanIfaceTest, IfacEventHandlers_OnStateToggleOffOn) {
// Ensure that event handlers are registered during nan iface creation.
iface_util::IfaceEventHandlers captured_iface_event_handlers = {};
EXPECT_CALL(*legacy_hal_, nanRegisterCallbackHandlers(testing::_, testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
EXPECT_CALL(*iface_util_, registerIfaceEventHandlers(testing::_, testing::_))
.WillOnce(testing::Invoke(bind(CaptureIfaceEventHandlers, std::placeholders::_1,
std::placeholders::_2, &captured_iface_event_handlers)));
// Create nan iface and register a callback.
// Note: Since we can't register a callback directly (gTest fails on
// AIBinder_linkToDeath), simulate the registration by overriding
// getEventCallbacks() to return our mock callback object.
std::shared_ptr<MockNanIface> mock_nan_iface =
MockNanIface::createMock(kIfaceName, false, legacy_hal_, iface_util_);
std::shared_ptr<MockNanIfaceEventCallback> mock_event_callback =
ndk::SharedRefBase::make<MockNanIfaceEventCallback>();
mock_nan_iface->setMockCallback(mock_event_callback);
// Ensure that the eventDisabled() function in the mock callback will be invoked.
NanStatus expected_nan_status = {NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
EXPECT_CALL(*mock_event_callback, eventDisabled(expected_nan_status)).Times(1);
// Trigger the iface state toggle callback.
captured_iface_event_handlers.on_state_toggle_off_on(kIfaceName);
}
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

166
wifi/1.6/default/wifi.cpp → wifi/aidl/default/wifi.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include "wifi.h"
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "wifi.h"
#include "aidl_return_util.h"
#include "wifi_status_util.h"
namespace {
// Starting Chip ID, will be assigned to primary chip
static constexpr android::hardware::wifi::V1_0::ChipId kPrimaryChipId = 0;
static constexpr int32_t kPrimaryChipId = 0;
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
using hidl_return_util::validateAndCallWithLock;
using aidl_return_util::validateAndCall;
using aidl_return_util::validateAndCallWithLock;
Wifi::Wifi(const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
Wifi::Wifi(const std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags)
@@ -48,86 +48,74 @@ bool Wifi::isValid() {
return true;
}
Return<void> Wifi::registerEventCallback(const sp<V1_0::IWifiEventCallback>& event_callback,
registerEventCallback_cb hidl_status_cb) {
ndk::ScopedAStatus Wifi::registerEventCallback(
const std::shared_ptr<IWifiEventCallback>& in_callback) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::registerEventCallbackInternal, hidl_status_cb, event_callback);
&Wifi::registerEventCallbackInternal, in_callback);
}
Return<void> Wifi::registerEventCallback_1_5(const sp<V1_5::IWifiEventCallback>& event_callback,
registerEventCallback_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::registerEventCallbackInternal_1_5, hidl_status_cb,
event_callback);
ndk::ScopedAStatus Wifi::isStarted(bool* _aidl_return) {
*_aidl_return = (run_state_ != RunState::STOPPED);
return ndk::ScopedAStatus::ok();
}
Return<bool> Wifi::isStarted() {
return run_state_ != RunState::STOPPED;
ndk::ScopedAStatus Wifi::start() {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::startInternal);
}
Return<void> Wifi::start(start_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::startInternal,
hidl_status_cb);
ndk::ScopedAStatus Wifi::stop() {
return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::stopInternal);
}
Return<void> Wifi::stop(stop_cb hidl_status_cb) {
return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::stopInternal,
hidl_status_cb);
}
Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
ndk::ScopedAStatus Wifi::getChipIds(std::vector<int32_t>* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipIdsInternal,
hidl_status_cb);
_aidl_return);
}
Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
ndk::ScopedAStatus Wifi::getChip(int32_t in_chipId, std::shared_ptr<IWifiChip>* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipInternal,
hidl_status_cb, chip_id);
_aidl_return, in_chipId);
}
Return<void> Wifi::debug(const hidl_handle& handle, const hidl_vec<hidl_string>&) {
LOG(INFO) << "-----------Debug is called----------------";
binder_status_t Wifi::dump(int fd, const char** args, uint32_t numArgs) {
LOG(INFO) << "-----------Debug was called----------------";
if (chips_.size() == 0) {
return Void();
LOG(INFO) << "No chips to display.";
return STATUS_OK;
}
for (sp<WifiChip> chip : chips_) {
for (std::shared_ptr<WifiChip> chip : chips_) {
if (!chip.get()) continue;
chip->debug(handle, {});
chip->dump(fd, args, numArgs);
}
return Void();
return STATUS_OK;
}
WifiStatus Wifi::registerEventCallbackInternal(
const sp<V1_0::IWifiEventCallback>& event_callback __unused) {
// Deprecated support for this callback.
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus Wifi::registerEventCallbackInternal_1_5(
const sp<V1_5::IWifiEventCallback>& event_callback) {
ndk::ScopedAStatus Wifi::registerEventCallbackInternal(
const std::shared_ptr<IWifiEventCallback>& event_callback) {
if (!event_cb_handler_.addCallback(event_callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
return ndk::ScopedAStatus::ok();
}
WifiStatus Wifi::startInternal() {
ndk::ScopedAStatus Wifi::startInternal() {
if (run_state_ == RunState::STARTED) {
return createWifiStatus(WifiStatusCode::SUCCESS);
return ndk::ScopedAStatus::ok();
} else if (run_state_ == RunState::STOPPING) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
}
WifiStatus wifi_status = initializeModeControllerAndLegacyHal();
if (wifi_status.code == WifiStatusCode::SUCCESS) {
ndk::ScopedAStatus wifi_status = initializeModeControllerAndLegacyHal();
if (wifi_status.isOk()) {
// Register the callback for subsystem restart
const auto& on_subsystem_restart_callback = [this](const std::string& error) {
WifiStatus wifi_status = createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, error);
ndk::ScopedAStatus wifi_status = createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, error);
for (const auto& callback : event_cb_handler_.getCallbacks()) {
LOG(INFO) << "Attempting to invoke onSubsystemRestart "
"callback";
if (!callback->onSubsystemRestart(wifi_status).isOk()) {
WifiStatusCode errorCode =
static_cast<WifiStatusCode>(wifi_status.getServiceSpecificError());
if (!callback->onSubsystemRestart(errorCode).isOk()) {
LOG(ERROR) << "Failed to invoke onSubsystemRestart callback";
} else {
LOG(INFO) << "Succeeded to invoke onSubsystemRestart "
@@ -137,12 +125,12 @@ WifiStatus Wifi::startInternal() {
};
// Create the chip instance once the HAL is started.
android::hardware::wifi::V1_0::ChipId chipId = kPrimaryChipId;
int32_t chipId = kPrimaryChipId;
for (auto& hal : legacy_hals_) {
chips_.push_back(
new WifiChip(chipId, chipId == kPrimaryChipId, hal, mode_controller_,
std::make_shared<iface_util::WifiIfaceUtil>(iface_tool_, hal),
feature_flags_, on_subsystem_restart_callback));
WifiChip::create(chipId, chipId == kPrimaryChipId, hal, mode_controller_,
std::make_shared<iface_util::WifiIfaceUtil>(iface_tool_, hal),
feature_flags_, on_subsystem_restart_callback));
chipId++;
}
run_state_ = RunState::STARTED;
@@ -154,7 +142,9 @@ WifiStatus Wifi::startInternal() {
LOG(INFO) << "Wifi HAL started";
} else {
for (const auto& callback : event_cb_handler_.getCallbacks()) {
if (!callback->onFailure(wifi_status).isOk()) {
WifiStatusCode errorCode =
static_cast<WifiStatusCode>(wifi_status.getServiceSpecificError());
if (!callback->onFailure(errorCode).isOk()) {
LOG(ERROR) << "Failed to invoke onFailure callback";
}
}
@@ -165,10 +155,10 @@ WifiStatus Wifi::startInternal() {
return wifi_status;
}
WifiStatus Wifi::stopInternal(
ndk::ScopedAStatus Wifi::stopInternal(
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
if (run_state_ == RunState::STOPPED) {
return createWifiStatus(WifiStatusCode::SUCCESS);
return ndk::ScopedAStatus::ok();
} else if (run_state_ == RunState::STOPPING) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
}
@@ -177,12 +167,12 @@ WifiStatus Wifi::stopInternal(
for (auto& chip : chips_) {
if (chip.get()) {
chip->invalidate();
chip.clear();
chip.reset();
}
}
chips_.clear();
WifiStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
if (wifi_status.code == WifiStatusCode::SUCCESS) {
ndk::ScopedAStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
if (wifi_status.isOk()) {
for (const auto& callback : event_cb_handler_.getCallbacks()) {
if (!callback->onStop().isOk()) {
LOG(ERROR) << "Failed to invoke onStop callback";
@@ -191,7 +181,9 @@ WifiStatus Wifi::stopInternal(
LOG(INFO) << "Wifi HAL stopped";
} else {
for (const auto& callback : event_cb_handler_.getCallbacks()) {
if (!callback->onFailure(wifi_status).isOk()) {
WifiStatusCode errorCode =
static_cast<WifiStatusCode>(wifi_status.getServiceSpecificError());
if (!callback->onFailure(errorCode).isOk()) {
LOG(ERROR) << "Failed to invoke onFailure callback";
}
}
@@ -202,27 +194,26 @@ WifiStatus Wifi::stopInternal(
return wifi_status;
}
std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
std::vector<ChipId> chip_ids;
std::pair<std::vector<int32_t>, ndk::ScopedAStatus> Wifi::getChipIdsInternal() {
std::vector<int32_t> chip_ids;
for (auto& chip : chips_) {
ChipId chip_id = getChipIdFromWifiChip(chip);
if (chip_id != UINT32_MAX) chip_ids.emplace_back(chip_id);
int32_t chip_id = getChipIdFromWifiChip(chip);
if (chip_id != INT32_MAX) chip_ids.emplace_back(chip_id);
}
return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
return {std::move(chip_ids), ndk::ScopedAStatus::ok()};
}
std::pair<WifiStatus, sp<V1_4::IWifiChip>> Wifi::getChipInternal(ChipId chip_id) {
std::pair<std::shared_ptr<IWifiChip>, ndk::ScopedAStatus> Wifi::getChipInternal(int32_t chip_id) {
for (auto& chip : chips_) {
ChipId cand_id = getChipIdFromWifiChip(chip);
if ((cand_id != UINT32_MAX) && (cand_id == chip_id))
return {createWifiStatus(WifiStatusCode::SUCCESS), chip};
int32_t cand_id = getChipIdFromWifiChip(chip);
if ((cand_id != INT32_MAX) && (cand_id == chip_id)) return {chip, ndk::ScopedAStatus::ok()};
}
return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
return {nullptr, createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS)};
}
WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
ndk::ScopedAStatus Wifi::initializeModeControllerAndLegacyHal() {
if (!mode_controller_->initialize()) {
LOG(ERROR) << "Failed to initialize firmware mode controller";
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
@@ -244,10 +235,10 @@ WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
}
index++;
}
return createWifiStatus(WifiStatusCode::SUCCESS);
return ndk::ScopedAStatus::ok();
}
WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
ndk::ScopedAStatus Wifi::stopLegacyHalAndDeinitializeModeController(
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
legacy_hal::wifi_error legacy_status = legacy_hal::WIFI_SUCCESS;
int index = 0;
@@ -272,23 +263,22 @@ WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
LOG(ERROR) << "Failed to deinitialize firmware mode controller";
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
return ndk::ScopedAStatus::ok();
}
ChipId Wifi::getChipIdFromWifiChip(sp<WifiChip>& chip) {
ChipId chip_id = UINT32_MAX;
int32_t Wifi::getChipIdFromWifiChip(std::shared_ptr<WifiChip>& chip) {
int32_t chip_id = INT32_MAX;
if (chip.get()) {
chip->getId([&](WifiStatus status, uint32_t id) {
if (status.code == WifiStatusCode::SUCCESS) {
chip_id = id;
}
});
ndk::ScopedAStatus status = chip->getId(&chip_id);
if (!status.isOk()) {
// Reset value if operation failed.
chip_id = INT32_MAX;
}
}
return chip_id;
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

96
wifi/aidl/default/wifi.h Normal file
View File

@@ -0,0 +1,96 @@
/*
* 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.
*/
#ifndef WIFI_H_
#define WIFI_H_
#include <aidl/android/hardware/wifi/BnWifi.h>
#include <android-base/macros.h>
#include <utils/Looper.h>
#include <functional>
#include "aidl_callback_util.h"
#include "wifi_chip.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_legacy_hal_factory.h"
#include "wifi_mode_controller.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
/**
* Root AIDL interface object used to control the Wifi HAL.
*/
class Wifi : public BnWifi {
public:
Wifi(const std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags);
bool isValid();
// AIDL methods exposed.
ndk::ScopedAStatus registerEventCallback(
const std::shared_ptr<IWifiEventCallback>& in_callback) override;
ndk::ScopedAStatus isStarted(bool* _aidl_return) override;
ndk::ScopedAStatus start() override;
ndk::ScopedAStatus stop() override;
ndk::ScopedAStatus getChipIds(std::vector<int32_t>* _aidl_return) override;
ndk::ScopedAStatus getChip(int32_t in_chipId,
std::shared_ptr<IWifiChip>* _aidl_return) override;
binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
private:
enum class RunState { STOPPED, STARTED, STOPPING };
// Corresponding worker functions for the AIDL methods.
ndk::ScopedAStatus registerEventCallbackInternal(
const std::shared_ptr<IWifiEventCallback>& event_callback __unused);
ndk::ScopedAStatus startInternal();
ndk::ScopedAStatus stopInternal(std::unique_lock<std::recursive_mutex>* lock);
std::pair<std::vector<int32_t>, ndk::ScopedAStatus> getChipIdsInternal();
std::pair<std::shared_ptr<IWifiChip>, ndk::ScopedAStatus> getChipInternal(int32_t chip_id);
ndk::ScopedAStatus initializeModeControllerAndLegacyHal();
ndk::ScopedAStatus stopLegacyHalAndDeinitializeModeController(
std::unique_lock<std::recursive_mutex>* lock);
int32_t getChipIdFromWifiChip(std::shared_ptr<WifiChip>& chip);
// Instance is created in this root level |IWifi| AIDL interface object
// and shared with all the child AIDL interface objects.
std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory_;
std::shared_ptr<mode_controller::WifiModeController> mode_controller_;
std::vector<std::shared_ptr<legacy_hal::WifiLegacyHal>> legacy_hals_;
std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags_;
RunState run_state_;
std::vector<std::shared_ptr<WifiChip>> chips_;
aidl_callback_util::AidlCallbackHandler<IWifiEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(Wifi);
};
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_H_

118
wifi/1.6/default/wifi_ap_iface.cpp → wifi/aidl/default/wifi_ap_iface.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -14,19 +14,19 @@
* limitations under the License.
*/
#include "wifi_ap_iface.h"
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "hidl_struct_util.h"
#include "wifi_ap_iface.h"
#include "aidl_return_util.h"
#include "aidl_struct_util.h"
#include "wifi_status_util.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
using aidl_return_util::validateAndCall;
WifiApIface::WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
@@ -54,76 +54,66 @@ void WifiApIface::removeInstance(std::string instance) {
instances_.erase(std::remove(instances_.begin(), instances_.end(), instance), instances_.end());
}
Return<void> WifiApIface::getName(getName_cb hidl_status_cb) {
ndk::ScopedAStatus WifiApIface::getName(std::string* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getNameInternal, hidl_status_cb);
&WifiApIface::getNameInternal, _aidl_return);
}
Return<void> WifiApIface::getType(getType_cb hidl_status_cb) {
ndk::ScopedAStatus WifiApIface::setCountryCode(const std::array<uint8_t, 2>& in_code) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getTypeInternal, hidl_status_cb);
&WifiApIface::setCountryCodeInternal, in_code);
}
Return<void> WifiApIface::setCountryCode(const hidl_array<int8_t, 2>& code,
setCountryCode_cb hidl_status_cb) {
ndk::ScopedAStatus WifiApIface::getValidFrequenciesForBand(WifiBand in_band,
std::vector<int32_t>* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::setCountryCodeInternal, hidl_status_cb, code);
&WifiApIface::getValidFrequenciesForBandInternal, _aidl_return, in_band);
}
Return<void> WifiApIface::getValidFrequenciesForBand(V1_0::WifiBand band,
getValidFrequenciesForBand_cb hidl_status_cb) {
ndk::ScopedAStatus WifiApIface::setMacAddress(const std::array<uint8_t, 6>& in_mac) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getValidFrequenciesForBandInternal, hidl_status_cb, band);
&WifiApIface::setMacAddressInternal, in_mac);
}
Return<void> WifiApIface::setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) {
ndk::ScopedAStatus WifiApIface::getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::setMacAddressInternal, hidl_status_cb, mac);
}
Return<void> WifiApIface::getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getFactoryMacAddressInternal, hidl_status_cb,
&WifiApIface::getFactoryMacAddressInternal, _aidl_return,
instances_.size() > 0 ? instances_[0] : ifname_);
}
Return<void> WifiApIface::resetToFactoryMacAddress(resetToFactoryMacAddress_cb hidl_status_cb) {
ndk::ScopedAStatus WifiApIface::resetToFactoryMacAddress() {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::resetToFactoryMacAddressInternal, hidl_status_cb);
&WifiApIface::resetToFactoryMacAddressInternal);
}
Return<void> WifiApIface::getBridgedInstances(getBridgedInstances_cb hidl_status_cb) {
ndk::ScopedAStatus WifiApIface::getBridgedInstances(std::vector<std::string>* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getBridgedInstancesInternal, hidl_status_cb);
&WifiApIface::getBridgedInstancesInternal, _aidl_return);
}
std::pair<WifiStatus, std::string> WifiApIface::getNameInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
std::pair<std::string, ndk::ScopedAStatus> WifiApIface::getNameInternal() {
return {ifname_, ndk::ScopedAStatus::ok()};
}
std::pair<WifiStatus, IfaceType> WifiApIface::getTypeInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::AP};
}
WifiStatus WifiApIface::setCountryCodeInternal(const std::array<int8_t, 2>& code) {
ndk::ScopedAStatus WifiApIface::setCountryCodeInternal(const std::array<uint8_t, 2>& code) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setCountryCode(
instances_.size() > 0 ? instances_[0] : ifname_, code);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
WifiApIface::getValidFrequenciesForBandInternal(V1_0::WifiBand band) {
static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), "Size mismatch");
std::pair<std::vector<int32_t>, ndk::ScopedAStatus> WifiApIface::getValidFrequenciesForBandInternal(
WifiBand band) {
static_assert(sizeof(WifiChannelWidthInMhz) == sizeof(int32_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(
instances_.size() > 0 ? instances_[0] : ifname_,
hidl_struct_util::convertHidlWifiBandToLegacy(band));
return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};
aidl_struct_util::convertAidlWifiBandToLegacy(band));
return {std::vector<int32_t>(valid_frequencies.begin(), valid_frequencies.end()),
createWifiStatusFromLegacyError(legacy_status)};
}
WifiStatus WifiApIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
ndk::ScopedAStatus WifiApIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
// Support random MAC up to 2 interfaces
if (instances_.size() == 2) {
int rbyte = 1;
@@ -145,35 +135,35 @@ WifiStatus WifiApIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac)
LOG(ERROR) << "Fail to config MAC for interface " << ifname_;
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
return ndk::ScopedAStatus::ok();
}
std::pair<WifiStatus, std::array<uint8_t, 6>> WifiApIface::getFactoryMacAddressInternal(
std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> WifiApIface::getFactoryMacAddressInternal(
const std::string& ifaceName) {
std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifaceName);
if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), mac};
return {mac, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), mac};
return {mac, ndk::ScopedAStatus::ok()};
}
WifiStatus WifiApIface::resetToFactoryMacAddressInternal() {
std::pair<WifiStatus, std::array<uint8_t, 6>> getMacResult;
ndk::ScopedAStatus WifiApIface::resetToFactoryMacAddressInternal() {
std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> getMacResult;
if (instances_.size() == 2) {
for (auto const& intf : instances_) {
getMacResult = getFactoryMacAddressInternal(intf);
LOG(DEBUG) << "Reset MAC to factory MAC on " << intf;
if (getMacResult.first.code != WifiStatusCode::SUCCESS ||
!iface_util_.lock()->setMacAddress(intf, getMacResult.second)) {
if (!getMacResult.second.isOk() ||
!iface_util_.lock()->setMacAddress(intf, getMacResult.first)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
}
// It needs to set mac address for bridged interface, otherwise the mac
// We need to set mac address for bridged interface, otherwise the mac
// address of the bridged interface will be changed after one of the
// instance down. Thus we are generating a random MAC address for the
// bridged interface even if we got the request to reset the Factory
// MAC. Since the bridged interface is an internal interface for the
// operation of bpf and others networking operation.
// instances goes down. Thus we are generating a random MAC address for
// the bridged interface even if we got the request to reset the Factory
// MAC. This is because the bridged interface is an internal interface
// for the operation of bpf and other networking operations.
if (!iface_util_.lock()->setMacAddress(ifname_,
iface_util_.lock()->createRandomMacAddress())) {
LOG(ERROR) << "Fail to config MAC for bridged interface " << ifname_;
@@ -182,23 +172,19 @@ WifiStatus WifiApIface::resetToFactoryMacAddressInternal() {
} else {
getMacResult = getFactoryMacAddressInternal(ifname_);
LOG(DEBUG) << "Reset MAC to factory MAC on " << ifname_;
if (getMacResult.first.code != WifiStatusCode::SUCCESS ||
!iface_util_.lock()->setMacAddress(ifname_, getMacResult.second)) {
if (!getMacResult.second.isOk() ||
!iface_util_.lock()->setMacAddress(ifname_, getMacResult.first)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
}
return createWifiStatus(WifiStatusCode::SUCCESS);
return ndk::ScopedAStatus::ok();
}
std::pair<WifiStatus, std::vector<hidl_string>> WifiApIface::getBridgedInstancesInternal() {
std::vector<hidl_string> instances;
for (const auto& instance_name : instances_) {
instances.push_back(instance_name);
}
return {createWifiStatus(WifiStatusCode::SUCCESS), instances};
std::pair<std::vector<std::string>, ndk::ScopedAStatus> WifiApIface::getBridgedInstancesInternal() {
return {instances_, ndk::ScopedAStatus::ok()};
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

81
wifi/aidl/default/wifi_ap_iface.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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.
*/
#ifndef WIFI_AP_IFACE_H_
#define WIFI_AP_IFACE_H_
#include <aidl/android/hardware/wifi/BnWifiApIface.h>
#include <android-base/macros.h>
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
/**
* AIDL interface object used to control an AP Iface instance.
*/
class WifiApIface : public BnWifiApIface {
public:
WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::string getName();
void removeInstance(std::string instance);
// AIDL methods exposed.
ndk::ScopedAStatus getName(std::string* _aidl_return) override;
ndk::ScopedAStatus setCountryCode(const std::array<uint8_t, 2>& in_code) override;
ndk::ScopedAStatus getValidFrequenciesForBand(WifiBand in_band,
std::vector<int32_t>* _aidl_return) override;
ndk::ScopedAStatus setMacAddress(const std::array<uint8_t, 6>& in_mac) override;
ndk::ScopedAStatus getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) override;
ndk::ScopedAStatus resetToFactoryMacAddress() override;
ndk::ScopedAStatus getBridgedInstances(std::vector<std::string>* _aidl_return) override;
private:
// Corresponding worker functions for the AIDL methods.
std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
ndk::ScopedAStatus setCountryCodeInternal(const std::array<uint8_t, 2>& code);
std::pair<std::vector<int32_t>, ndk::ScopedAStatus> getValidFrequenciesForBandInternal(
WifiBand band);
ndk::ScopedAStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> getFactoryMacAddressInternal(
const std::string& ifaceName);
ndk::ScopedAStatus resetToFactoryMacAddressInternal();
std::pair<std::vector<std::string>, ndk::ScopedAStatus> getBridgedInstancesInternal();
std::string ifname_;
std::vector<std::string> instances_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
DISALLOW_COPY_AND_ASSIGN(WifiApIface);
};
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_AP_IFACE_H_

1046
wifi/1.6/default/wifi_chip.cpp → wifi/aidl/default/wifi_chip.cpp
View File

File diff suppressed because it is too large Load Diff

287
wifi/aidl/default/wifi_chip.h Normal file
View File

@@ -0,0 +1,287 @@
/*
* 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.
*/
#ifndef WIFI_CHIP_H_
#define WIFI_CHIP_H_
#include <aidl/android/hardware/wifi/BnWifiChip.h>
#include <aidl/android/hardware/wifi/IWifiRttController.h>
#include <android-base/macros.h>
#include <list>
#include <map>
#include <mutex>
#include "aidl_callback_util.h"
#include "ringbuffer.h"
#include "wifi_ap_iface.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_mode_controller.h"
#include "wifi_nan_iface.h"
#include "wifi_p2p_iface.h"
#include "wifi_rtt_controller.h"
#include "wifi_sta_iface.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
/**
* AIDL interface object used to control a Wifi HAL chip instance.
* Since there is only a single chip instance used today, there is no
* identifying handle information stored here.
*/
class WifiChip : public BnWifiChip {
public:
WifiChip(int32_t chip_id, bool is_primary,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
const std::function<void(const std::string&)>& subsystemCallbackHandler);
// Factory method - use instead of default constructor.
static std::shared_ptr<WifiChip> create(
int32_t chip_id, bool is_primary,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util,
const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags,
const std::function<void(const std::string&)>& subsystemCallbackHandler);
// AIDL does not provide a built-in mechanism to let the server invalidate
// an AIDL interface object after creation. If any client process holds onto
// a reference to the object in their context, any method calls on that
// reference will continue to be directed to the server.
//
// However Wifi HAL needs to control the lifetime of these objects. So, add
// a public |invalidate| method to |WifiChip| and its child objects. This
// will be used to mark an object invalid when either:
// a) Wifi HAL is stopped, or
// b) Wifi Chip is reconfigured.
//
// All AIDL method implementations should check if the object is still
// marked valid before processing them.
void invalidate();
bool isValid();
std::set<std::shared_ptr<IWifiChipEventCallback>> getEventCallbacks();
// AIDL methods exposed.
ndk::ScopedAStatus getId(int32_t* _aidl_return) override;
ndk::ScopedAStatus registerEventCallback(
const std::shared_ptr<IWifiChipEventCallback>& in_callback) override;
ndk::ScopedAStatus getCapabilities(IWifiChip::ChipCapabilityMask* _aidl_return) override;
ndk::ScopedAStatus getAvailableModes(std::vector<IWifiChip::ChipMode>* _aidl_return) override;
ndk::ScopedAStatus configureChip(int32_t in_modeId) override;
ndk::ScopedAStatus getMode(int32_t* _aidl_return) override;
ndk::ScopedAStatus requestChipDebugInfo(IWifiChip::ChipDebugInfo* _aidl_return) override;
ndk::ScopedAStatus requestDriverDebugDump(std::vector<uint8_t>* _aidl_return) override;
ndk::ScopedAStatus requestFirmwareDebugDump(std::vector<uint8_t>* _aidl_return) override;
ndk::ScopedAStatus createApIface(std::shared_ptr<IWifiApIface>* _aidl_return) override;
ndk::ScopedAStatus createBridgedApIface(std::shared_ptr<IWifiApIface>* _aidl_return) override;
ndk::ScopedAStatus getApIfaceNames(std::vector<std::string>* _aidl_return) override;
ndk::ScopedAStatus getApIface(const std::string& in_ifname,
std::shared_ptr<IWifiApIface>* _aidl_return) override;
ndk::ScopedAStatus removeApIface(const std::string& in_ifname) override;
ndk::ScopedAStatus removeIfaceInstanceFromBridgedApIface(
const std::string& in_brIfaceName, const std::string& in_ifaceInstanceName) override;
ndk::ScopedAStatus createNanIface(std::shared_ptr<IWifiNanIface>* _aidl_return) override;
ndk::ScopedAStatus getNanIfaceNames(std::vector<std::string>* _aidl_return) override;
ndk::ScopedAStatus getNanIface(const std::string& in_ifname,
std::shared_ptr<IWifiNanIface>* _aidl_return) override;
ndk::ScopedAStatus removeNanIface(const std::string& in_ifname) override;
ndk::ScopedAStatus createP2pIface(std::shared_ptr<IWifiP2pIface>* _aidl_return) override;
ndk::ScopedAStatus getP2pIfaceNames(std::vector<std::string>* _aidl_return) override;
ndk::ScopedAStatus getP2pIface(const std::string& in_ifname,
std::shared_ptr<IWifiP2pIface>* _aidl_return) override;
ndk::ScopedAStatus removeP2pIface(const std::string& in_ifname) override;
ndk::ScopedAStatus createStaIface(std::shared_ptr<IWifiStaIface>* _aidl_return) override;
ndk::ScopedAStatus getStaIfaceNames(std::vector<std::string>* _aidl_return) override;
ndk::ScopedAStatus getStaIface(const std::string& in_ifname,
std::shared_ptr<IWifiStaIface>* _aidl_return) override;
ndk::ScopedAStatus removeStaIface(const std::string& in_ifname) override;
ndk::ScopedAStatus createRttController(
const std::shared_ptr<IWifiStaIface>& in_boundIface,
std::shared_ptr<IWifiRttController>* _aidl_return) override;
ndk::ScopedAStatus getDebugRingBuffersStatus(
std::vector<WifiDebugRingBufferStatus>* _aidl_return) override;
ndk::ScopedAStatus startLoggingToDebugRingBuffer(
const std::string& in_ringName, WifiDebugRingBufferVerboseLevel in_verboseLevel,
int32_t in_maxIntervalInSec, int32_t in_minDataSizeInBytes) override;
ndk::ScopedAStatus forceDumpToDebugRingBuffer(const std::string& in_ringName) override;
ndk::ScopedAStatus flushRingBufferToFile() override;
ndk::ScopedAStatus stopLoggingToDebugRingBuffer() override;
ndk::ScopedAStatus getDebugHostWakeReasonStats(
WifiDebugHostWakeReasonStats* _aidl_return) override;
ndk::ScopedAStatus enableDebugErrorAlerts(bool in_enable) override;
ndk::ScopedAStatus selectTxPowerScenario(IWifiChip::TxPowerScenario in_scenario) override;
ndk::ScopedAStatus resetTxPowerScenario() override;
ndk::ScopedAStatus setLatencyMode(IWifiChip::LatencyMode in_mode) override;
ndk::ScopedAStatus setMultiStaPrimaryConnection(const std::string& in_ifName) override;
ndk::ScopedAStatus setMultiStaUseCase(IWifiChip::MultiStaUseCase in_useCase) override;
ndk::ScopedAStatus setCoexUnsafeChannels(
const std::vector<IWifiChip::CoexUnsafeChannel>& in_unsafeChannels,
CoexRestriction in_restrictions) override;
ndk::ScopedAStatus setCountryCode(const std::array<uint8_t, 2>& in_code) override;
ndk::ScopedAStatus getUsableChannels(WifiBand in_band, WifiIfaceMode in_ifaceModeMask,
UsableChannelFilter in_filterMask,
std::vector<WifiUsableChannel>* _aidl_return) override;
ndk::ScopedAStatus triggerSubsystemRestart() override;
ndk::ScopedAStatus getSupportedRadioCombinationsMatrix(
WifiRadioCombinationMatrix* _aidl_return) override;
binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
private:
void invalidateAndRemoveAllIfaces();
// When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are
// invalidated & removed.
void invalidateAndRemoveDependencies(const std::string& removed_iface_name);
// Corresponding worker functions for the AIDL methods.
std::pair<int32_t, ndk::ScopedAStatus> getIdInternal();
ndk::ScopedAStatus registerEventCallbackInternal(
const std::shared_ptr<IWifiChipEventCallback>& event_callback);
std::pair<IWifiChip::ChipCapabilityMask, ndk::ScopedAStatus> getCapabilitiesInternal();
std::pair<std::vector<IWifiChip::ChipMode>, ndk::ScopedAStatus> getAvailableModesInternal();
ndk::ScopedAStatus configureChipInternal(std::unique_lock<std::recursive_mutex>* lock,
int32_t mode_id);
std::pair<int32_t, ndk::ScopedAStatus> getModeInternal();
std::pair<IWifiChip::ChipDebugInfo, ndk::ScopedAStatus> requestChipDebugInfoInternal();
std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> requestDriverDebugDumpInternal();
std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> requestFirmwareDebugDumpInternal();
std::shared_ptr<WifiApIface> newWifiApIface(std::string& ifname);
ndk::ScopedAStatus createVirtualApInterface(const std::string& apVirtIf);
std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> createApIfaceInternal();
std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> createBridgedApIfaceInternal();
std::pair<std::vector<std::string>, ndk::ScopedAStatus> getApIfaceNamesInternal();
std::pair<std::shared_ptr<IWifiApIface>, ndk::ScopedAStatus> getApIfaceInternal(
const std::string& ifname);
ndk::ScopedAStatus removeApIfaceInternal(const std::string& ifname);
ndk::ScopedAStatus removeIfaceInstanceFromBridgedApIfaceInternal(
const std::string& brIfaceName, const std::string& ifInstanceName);
std::pair<std::shared_ptr<IWifiNanIface>, ndk::ScopedAStatus> createNanIfaceInternal();
std::pair<std::vector<std::string>, ndk::ScopedAStatus> getNanIfaceNamesInternal();
std::pair<std::shared_ptr<IWifiNanIface>, ndk::ScopedAStatus> getNanIfaceInternal(
const std::string& ifname);
ndk::ScopedAStatus removeNanIfaceInternal(const std::string& ifname);
std::pair<std::shared_ptr<IWifiP2pIface>, ndk::ScopedAStatus> createP2pIfaceInternal();
std::pair<std::vector<std::string>, ndk::ScopedAStatus> getP2pIfaceNamesInternal();
std::pair<std::shared_ptr<IWifiP2pIface>, ndk::ScopedAStatus> getP2pIfaceInternal(
const std::string& ifname);
ndk::ScopedAStatus removeP2pIfaceInternal(const std::string& ifname);
std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> createStaIfaceInternal();
std::pair<std::vector<std::string>, ndk::ScopedAStatus> getStaIfaceNamesInternal();
std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> getStaIfaceInternal(
const std::string& ifname);
ndk::ScopedAStatus removeStaIfaceInternal(const std::string& ifname);
std::pair<std::shared_ptr<IWifiRttController>, ndk::ScopedAStatus> createRttControllerInternal(
const std::shared_ptr<IWifiStaIface>& bound_iface);
std::pair<std::vector<WifiDebugRingBufferStatus>, ndk::ScopedAStatus>
getDebugRingBuffersStatusInternal();
ndk::ScopedAStatus startLoggingToDebugRingBufferInternal(
const std::string& ring_name, WifiDebugRingBufferVerboseLevel verbose_level,
uint32_t max_interval_in_sec, uint32_t min_data_size_in_bytes);
ndk::ScopedAStatus forceDumpToDebugRingBufferInternal(const std::string& ring_name);
ndk::ScopedAStatus flushRingBufferToFileInternal();
ndk::ScopedAStatus stopLoggingToDebugRingBufferInternal();
std::pair<WifiDebugHostWakeReasonStats, ndk::ScopedAStatus>
getDebugHostWakeReasonStatsInternal();
ndk::ScopedAStatus enableDebugErrorAlertsInternal(bool enable);
ndk::ScopedAStatus selectTxPowerScenarioInternal(IWifiChip::TxPowerScenario scenario);
ndk::ScopedAStatus resetTxPowerScenarioInternal();
ndk::ScopedAStatus setLatencyModeInternal(IWifiChip::LatencyMode mode);
ndk::ScopedAStatus setMultiStaPrimaryConnectionInternal(const std::string& ifname);
ndk::ScopedAStatus setMultiStaUseCaseInternal(IWifiChip::MultiStaUseCase use_case);
ndk::ScopedAStatus setCoexUnsafeChannelsInternal(
std::vector<IWifiChip::CoexUnsafeChannel> unsafe_channels,
CoexRestriction restrictions);
ndk::ScopedAStatus setCountryCodeInternal(const std::array<uint8_t, 2>& in_code);
std::pair<std::vector<WifiUsableChannel>, ndk::ScopedAStatus> getUsableChannelsInternal(
WifiBand band, WifiIfaceMode ifaceModeMask, UsableChannelFilter filterMask);
ndk::ScopedAStatus handleChipConfiguration(std::unique_lock<std::recursive_mutex>* lock,
int32_t mode_id);
ndk::ScopedAStatus registerDebugRingBufferCallback();
ndk::ScopedAStatus registerRadioModeChangeCallback();
std::vector<ChipConcurrencyCombination> getCurrentModeConcurrencyCombinations();
std::map<IfaceConcurrencyType, size_t> getCurrentConcurrencyCombination();
std::vector<std::map<IfaceConcurrencyType, size_t>> expandConcurrencyCombinations(
const ChipConcurrencyCombination& combination);
bool canExpandedConcurrencyComboSupportConcurrencyTypeWithCurrentTypes(
const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
IfaceConcurrencyType requested_type);
bool canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType requested_type);
bool canExpandedConcurrencyComboSupportConcurrencyCombo(
const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
const std::map<IfaceConcurrencyType, size_t>& req_combo);
bool canCurrentModeSupportConcurrencyCombo(
const std::map<IfaceConcurrencyType, size_t>& req_combo);
bool canCurrentModeSupportConcurrencyType(IfaceConcurrencyType requested_type);
bool isValidModeId(int32_t mode_id);
bool isStaApConcurrencyAllowedInCurrentMode();
bool isDualStaConcurrencyAllowedInCurrentMode();
uint32_t startIdxOfApIface();
std::string getFirstActiveWlanIfaceName();
std::string allocateApOrStaIfaceName(IfaceType type, uint32_t start_idx);
std::string allocateApIfaceName();
std::vector<std::string> allocateBridgedApInstanceNames();
std::string allocateStaIfaceName();
bool writeRingbufferFilesInternal();
std::string getWlanIfaceNameWithType(IfaceType type, unsigned idx);
void invalidateAndClearBridgedApAll();
void invalidateAndClearBridgedAp(const std::string& br_name);
bool findUsingNameFromBridgedApInstances(const std::string& name);
ndk::ScopedAStatus triggerSubsystemRestartInternal();
std::pair<WifiRadioCombinationMatrix, ndk::ScopedAStatus>
getSupportedRadioCombinationsMatrixInternal();
void setWeakPtr(std::weak_ptr<WifiChip> ptr);
int32_t chip_id_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<mode_controller::WifiModeController> mode_controller_;
std::shared_ptr<iface_util::WifiIfaceUtil> iface_util_;
std::vector<std::shared_ptr<WifiApIface>> ap_ifaces_;
std::vector<std::shared_ptr<WifiNanIface>> nan_ifaces_;
std::vector<std::shared_ptr<WifiP2pIface>> p2p_ifaces_;
std::vector<std::shared_ptr<WifiStaIface>> sta_ifaces_;
std::vector<std::shared_ptr<WifiRttController>> rtt_controllers_;
std::map<std::string, Ringbuffer> ringbuffer_map_;
bool is_valid_;
// Members pertaining to chip configuration.
int32_t current_mode_id_;
std::mutex lock_t;
std::vector<IWifiChip::ChipMode> modes_;
// The legacy ring buffer callback API has only a global callback
// registration mechanism. Use this to check if we have already
// registered a callback.
bool debug_ring_buffer_cb_registered_;
aidl_callback_util::AidlCallbackHandler<IWifiChipEventCallback> event_cb_handler_;
std::weak_ptr<WifiChip> weak_ptr_this_;
const std::function<void(const std::string&)> subsystemCallbackHandler_;
std::map<std::string, std::vector<std::string>> br_ifaces_ap_instances_;
DISALLOW_COPY_AND_ASSIGN(WifiChip);
};
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_CHIP_H_

135
wifi/1.6/default/wifi_feature_flags.cpp → wifi/aidl/default/wifi_feature_flags.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -21,17 +21,12 @@
#include "wifi_feature_flags.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
using V1_0::ChipModeId;
using V1_0::IWifiChip;
using V1_6::IfaceConcurrencyType;
/* The chip may either have a single mode supporting any number of combinations,
* or a fixed dual-mode (so it involves firmware loading to switch between
* modes) setting. If there is a need to support more modes, it needs to be
@@ -41,7 +36,7 @@ using V1_6::IfaceConcurrencyType;
* Supported combinations are defined in device's makefile, for example:
* WIFI_HAL_INTERFACE_COMBINATIONS := {{{STA, AP}, 1}, {{P2P, NAN}, 1}},
* WIFI_HAL_INTERFACE_COMBINATIONS += {{{STA}, 1}, {{AP}, 2}}
* What means:
* What this means:
* Interface concurrency combination 1: 1 STA or AP and 1 P2P or NAN concurrent iface
* operations.
* Interface concurrency combination 2: 1 STA and 2 AP concurrent iface operations.
@@ -71,10 +66,10 @@ using V1_6::IfaceConcurrencyType;
*/
// clang-format off
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS
constexpr ChipModeId kMainModeId = chip_mode_ids::kV3;
constexpr int kMainModeId = chip_mode_ids::kV3;
#elif defined(WIFI_HIDL_FEATURE_DUAL_INTERFACE)
// former V2 (fixed dual interface) setup expressed as V3
constexpr ChipModeId kMainModeId = chip_mode_ids::kV3;
constexpr int kMainModeId = chip_mode_ids::kV3;
# ifdef WIFI_HIDL_FEATURE_DISABLE_AP
# ifdef WIFI_HIDL_FEATURE_AWARE
// 1 STA + 1 of (P2P or NAN)
@@ -96,7 +91,7 @@ constexpr ChipModeId kMainModeId = chip_mode_ids::kV3;
# endif
#else
// V1 (fixed single interface, dual-mode chip)
constexpr ChipModeId kMainModeId = chip_mode_ids::kV1Sta;
constexpr int kMainModeId = chip_mode_ids::kV1Sta;
# ifdef WIFI_HIDL_FEATURE_AWARE
// 1 STA + 1 of (P2P or NAN)
# define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P, NAN}, 1}}
@@ -111,44 +106,35 @@ constexpr ChipModeId kMainModeId = chip_mode_ids::kV1Sta;
#endif
// clang-format on
/**
* Helper class to convert a collection of combination limits to a combination.
*
* The main point here is to simplify the syntax required by
* WIFI_HAL_INTERFACE_COMBINATIONS.
*/
struct ChipConcurrencyCombination
: public hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombinationLimit> {
ChipConcurrencyCombination(
const std::initializer_list<V1_6::IWifiChip::ChipConcurrencyCombinationLimit> list)
: hidl_vec(list) {}
operator V1_6::IWifiChip::ChipConcurrencyCombination() const { return {*this}; }
static hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombination> make_vec(
const std::initializer_list<ChipConcurrencyCombination> list) {
return hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombination>( //
std::begin(list), std::end(list));
// Convert from the legacy format (used by the WIFI_HAL_INTERFACE_COMBINATIONS
// config variable) to a list of ChipConcurrencyCombination objects.
std::vector<IWifiChip::ChipConcurrencyCombination> legacyToChipConcurrencyComboList(
std::vector<std::vector<IWifiChip::ChipConcurrencyCombinationLimit>> legacyLimits) {
std::vector<IWifiChip::ChipConcurrencyCombination> combos;
for (auto& legacyLimit : legacyLimits) {
IWifiChip::ChipConcurrencyCombination combo = {legacyLimit};
combos.push_back(combo);
}
};
return combos;
}
#define STA IfaceConcurrencyType::STA
#define AP IfaceConcurrencyType::AP
#define AP_BRIDGED IfaceConcurrencyType::AP_BRIDGED
#define P2P IfaceConcurrencyType::P2P
#define NAN IfaceConcurrencyType::NAN
static const std::vector<V1_6::IWifiChip::ChipMode> kChipModesPrimary{
{kMainModeId, ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS})},
#define NAN IfaceConcurrencyType::NAN_IFACE
static const std::vector<IWifiChip::ChipMode> kChipModesPrimary{
{kMainModeId, legacyToChipConcurrencyComboList({WIFI_HAL_INTERFACE_COMBINATIONS})},
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_AP
{chip_mode_ids::kV1Ap,
ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_AP})},
legacyToChipConcurrencyComboList({WIFI_HAL_INTERFACE_COMBINATIONS_AP})},
#endif
};
static const std::vector<V1_6::IWifiChip::ChipMode> kChipModesSecondary{
static const std::vector<IWifiChip::ChipMode> kChipModesSecondary{
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP
{chip_mode_ids::kV3,
ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP})},
legacyToChipConcurrencyComboList({WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP})},
#endif
};
@@ -157,50 +143,46 @@ constexpr char kDebugPresetInterfaceCombinationIdxProperty[] =
// List of pre-defined concurrency combinations that can be enabled at runtime via
// setting the property: "kDebugPresetInterfaceCombinationIdxProperty" to the
// corresponding index value.
static const std::vector<std::pair<std::string, std::vector<V1_6::IWifiChip::ChipMode>>>
kDebugChipModes{// Legacy combination - No STA/AP concurrencies.
// 0 - (1 AP) or (1 STA + 1 of (P2P or NAN))
{"No STA/AP Concurrency",
{{kMainModeId, ChipConcurrencyCombination::make_vec(
{{{{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
static const std::vector<std::pair<std::string, std::vector<IWifiChip::ChipMode>>> kDebugChipModes{
// Legacy combination - No STA/AP concurrencies.
// 0 - (1 AP) or (1 STA + 1 of (P2P or NAN))
{"No STA/AP Concurrency",
{{kMainModeId,
legacyToChipConcurrencyComboList({{{{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// STA + AP concurrency
// 1 - (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
{"STA + AP Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// STA + AP concurrency
// 1 - (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
{"STA + AP Concurrency",
{{kMainModeId, legacyToChipConcurrencyComboList(
{{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency
// 2 - (1 STA + 1 AP) or (2 STA + 1 of (P2P or NAN))
{"Dual STA Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency
// 2 - (1 STA + 1 AP) or (2 STA + 1 of (P2P or NAN))
{"Dual STA Concurrency",
{{kMainModeId, legacyToChipConcurrencyComboList(
{{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
// AP + AP + STA concurrency
// 3 - (1 STA + 2 AP) or (1 STA + 1 of (P2P or NAN))
{"Dual AP Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// AP + AP + STA concurrency
// 3 - (1 STA + 2 AP) or (1 STA + 1 of (P2P or NAN))
{"Dual AP Concurrency",
{{kMainModeId, legacyToChipConcurrencyComboList(
{{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency and AP + AP + STA concurrency
// 4 - (1 STA + 2 AP) or (2 STA + 1 of (P2P or NAN))
{"Dual STA & Dual AP Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency and AP + AP + STA concurrency
// 4 - (1 STA + 2 AP) or (2 STA + 1 of (P2P or NAN))
{"Dual STA & Dual AP Concurrency",
{{kMainModeId, legacyToChipConcurrencyComboList(
{{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency
// 5 - (1 STA + 1 AP (bridged or single) | P2P | NAN), or (2 STA))
{"Dual STA or STA plus single other interface",
{{kMainModeId, ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{P2P, NAN, AP, AP_BRIDGED}, 1}},
{{{STA}, 2}}})}}}};
// STA + STA concurrency
// 5 - (1 STA + 1 AP (bridged or single) | P2P | NAN), or (2 STA))
{"Dual STA or STA plus single other interface",
{{kMainModeId, legacyToChipConcurrencyComboList(
{{{{STA}, 1}, {{P2P, NAN, AP, AP_BRIDGED}, 1}}, {{{STA}, 2}}})}}}};
#undef STA
#undef AP
#undef AP_BRIDGED
#undef P2P
#undef NAN
@@ -214,7 +196,7 @@ static const std::vector<std::pair<std::string, std::vector<V1_6::IWifiChip::Chi
WifiFeatureFlags::WifiFeatureFlags() {}
std::vector<V1_6::IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary() {
std::vector<IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary() {
std::array<char, PROPERTY_VALUE_MAX> buffer;
auto res = property_get(kDebugPresetInterfaceCombinationIdxProperty, buffer.data(), nullptr);
// Debug property not set, use the device preset concurrency combination.
@@ -228,20 +210,19 @@ std::vector<V1_6::IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary(
return kChipModesPrimary;
}
std::string name;
std::vector<V1_6::IWifiChip::ChipMode> chip_modes;
std::vector<IWifiChip::ChipMode> chip_modes;
std::tie(name, chip_modes) = kDebugChipModes[idx];
LOG(INFO) << "Using debug chip mode: <" << name
<< "> set via property: " << kDebugPresetInterfaceCombinationIdxProperty;
return chip_modes;
}
std::vector<V1_6::IWifiChip::ChipMode> WifiFeatureFlags::getChipModes(bool is_primary) {
std::vector<IWifiChip::ChipMode> WifiFeatureFlags::getChipModes(bool is_primary) {
return (is_primary) ? getChipModesForPrimary() : kChipModesSecondary;
}
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

24
wifi/1.6/default/wifi_feature_flags.h → wifi/aidl/default/wifi_feature_flags.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -17,24 +17,23 @@
#ifndef WIFI_FEATURE_FLAGS_H_
#define WIFI_FEATURE_FLAGS_H_
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <aidl/android/hardware/wifi/IWifiChip.h>
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
namespace chip_mode_ids {
// These mode ID's should be unique (even across combo versions). Refer to
// handleChipConfiguration() for it's usage.
constexpr V1_0::ChipModeId kInvalid = UINT32_MAX;
// handleChipConfiguration() for its usage.
constexpr uint32_t kInvalid = UINT32_MAX;
// Mode ID's for V1
constexpr V1_0::ChipModeId kV1Sta = 0;
constexpr V1_0::ChipModeId kV1Ap = 1;
constexpr uint32_t kV1Sta = 0;
constexpr uint32_t kV1Ap = 1;
// Mode ID for V3
constexpr V1_0::ChipModeId kV3 = 3;
constexpr uint32_t kV3 = 3;
} // namespace chip_mode_ids
class WifiFeatureFlags {
@@ -42,17 +41,16 @@ class WifiFeatureFlags {
WifiFeatureFlags();
virtual ~WifiFeatureFlags() = default;
virtual std::vector<V1_6::IWifiChip::ChipMode> getChipModes(bool is_primary);
virtual std::vector<IWifiChip::ChipMode> getChipModes(bool is_primary);
private:
std::vector<V1_6::IWifiChip::ChipMode> getChipModesForPrimary();
std::vector<IWifiChip::ChipMode> getChipModesForPrimary();
};
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_FEATURE_FLAGS_H_

20
wifi/1.6/default/wifi_iface_util.cpp → wifi/aidl/default/wifi_iface_util.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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.
@@ -14,33 +14,32 @@
* limitations under the License.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <net/if.h>
#include <private/android_filesystem_config.h>
#include <cstddef>
#include <iostream>
#include <limits>
#include <random>
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <private/android_filesystem_config.h>
#undef NAN
#include "wifi_iface_util.h"
namespace {
// Constants to set the local bit & clear the multicast bit.
constexpr uint8_t kMacAddressMulticastMask = 0x01;
constexpr uint8_t kMacAddressLocallyAssignedMask = 0x02;
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
WifiIfaceUtil::WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
WifiIfaceUtil::WifiIfaceUtil(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: iface_tool_(iface_tool),
legacy_hal_(legacy_hal),
@@ -169,8 +168,7 @@ bool WifiIfaceUtil::removeIfaceFromBridge(const std::string& br_name, const std:
}
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

15
wifi/1.6/default/wifi_iface_util.h → wifi/aidl/default/wifi_iface_util.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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.
@@ -17,17 +17,15 @@
#ifndef WIFI_IFACE_UTIL_H_
#define WIFI_IFACE_UTIL_H_
#include <aidl/android/hardware/wifi/IWifi.h>
#include <wifi_system/interface_tool.h>
#include <android/hardware/wifi/1.0/IWifi.h>
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
// Iface event handlers.
@@ -42,7 +40,7 @@ struct IfaceEventHandlers {
*/
class WifiIfaceUtil {
public:
WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
WifiIfaceUtil(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
virtual ~WifiIfaceUtil() = default;
@@ -71,17 +69,16 @@ class WifiIfaceUtil {
virtual std::array<uint8_t, 6> createRandomMacAddress();
private:
std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::unique_ptr<std::array<uint8_t, 6>> random_mac_address_;
std::map<std::string, IfaceEventHandlers> event_handlers_map_;
};
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_IFACE_UTIL_H_

154
wifi/1.6/default/wifi_legacy_hal.cpp → wifi/aidl/default/wifi_legacy_hal.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -14,15 +14,16 @@
* limitations under the License.
*/
#include <array>
#include <chrono>
#include "wifi_legacy_hal.h"
#include <android-base/logging.h>
#include <cutils/properties.h>
#include <net/if.h>
#include "hidl_sync_util.h"
#include "wifi_legacy_hal.h"
#include <array>
#include <chrono>
#include "aidl_sync_util.h"
#include "wifi_legacy_hal_stubs.h"
namespace {
@@ -38,7 +39,7 @@ static constexpr uint32_t kMaxWakeReasonStatsArraySize = 32;
static constexpr uint32_t kMaxRingBuffers = 10;
static constexpr uint32_t kMaxWifiUsableChannels = 256;
static constexpr uint32_t kMaxSupportedRadioCombinationsMatrixLength = 256;
// need a long timeout (1000ms) for chips that unload their driver.
// Need a long timeout (1000ms) for chips that unload their driver.
static constexpr uint32_t kMaxStopCompleteWaitMs = 1000;
static constexpr char kDriverPropName[] = "wlan.driver.status";
@@ -51,11 +52,10 @@ std::vector<char> makeCharVec(const std::string& str) {
}
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
// Legacy HAL functions accept "C" style function pointers, so use global
@@ -65,7 +65,7 @@ namespace legacy_hal {
// Callback to be invoked once |stop| is complete
std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
void onAsyncStopComplete(wifi_handle handle) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_stop_complete_internal_callback) {
on_stop_complete_internal_callback(handle);
// Invalidate this callback since we don't want this firing again.
@@ -92,7 +92,7 @@ void onSyncFirmwareMemoryDump(char* buffer, int buffer_size) {
// Callback to be invoked for Gscan events.
std::function<void(wifi_request_id, wifi_scan_event)> on_gscan_event_internal_callback;
void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_gscan_event_internal_callback) {
on_gscan_event_internal_callback(id, event);
}
@@ -103,7 +103,7 @@ std::function<void(wifi_request_id, wifi_scan_result*, uint32_t)>
on_gscan_full_result_internal_callback;
void onAsyncGscanFullResult(wifi_request_id id, wifi_scan_result* result,
uint32_t buckets_scanned) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_gscan_full_result_internal_callback) {
on_gscan_full_result_internal_callback(id, result, buckets_scanned);
}
@@ -123,7 +123,7 @@ void onSyncLinkLayerStatsResult(wifi_request_id id, wifi_iface_stat* iface_stat,
std::function<void((wifi_request_id, uint8_t*, int8_t))>
on_rssi_threshold_breached_internal_callback;
void onAsyncRssiThresholdBreached(wifi_request_id id, uint8_t* bssid, int8_t rssi) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_rssi_threshold_breached_internal_callback) {
on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
}
@@ -134,7 +134,7 @@ std::function<void(char*, char*, int, wifi_ring_buffer_status*)>
on_ring_buffer_data_internal_callback;
void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
wifi_ring_buffer_status* status) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_ring_buffer_data_internal_callback) {
on_ring_buffer_data_internal_callback(ring_name, buffer, buffer_size, status);
}
@@ -143,7 +143,7 @@ void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
// Callback to be invoked for error alert indication.
std::function<void(wifi_request_id, char*, int, int)> on_error_alert_internal_callback;
void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size, int err_code) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_error_alert_internal_callback) {
on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
}
@@ -153,7 +153,7 @@ void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size, int er
std::function<void(wifi_request_id, uint32_t, wifi_mac_info*)>
on_radio_mode_change_internal_callback;
void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs, wifi_mac_info* mac_infos) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_radio_mode_change_internal_callback) {
on_radio_mode_change_internal_callback(id, num_macs, mac_infos);
}
@@ -162,7 +162,7 @@ void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs, wifi_mac_info
// Callback to be invoked to report subsystem restart
std::function<void(const char*)> on_subsystem_restart_internal_callback;
void onAsyncSubsystemRestart(const char* error) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_subsystem_restart_internal_callback) {
on_subsystem_restart_internal_callback(error);
}
@@ -172,7 +172,7 @@ void onAsyncSubsystemRestart(const char* error) {
std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result* rtt_results[])>
on_rtt_results_internal_callback;
void onAsyncRttResults(wifi_request_id id, unsigned num_results, wifi_rtt_result* rtt_results[]) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_rtt_results_internal_callback) {
on_rtt_results_internal_callback(id, num_results, rtt_results);
on_rtt_results_internal_callback = nullptr;
@@ -184,37 +184,37 @@ void onAsyncRttResults(wifi_request_id id, unsigned num_results, wifi_rtt_result
// callbacks.
// So, handle all of them here directly to avoid adding an unnecessary layer.
std::function<void(transaction_id, const NanResponseMsg&)> on_nan_notify_response_user_callback;
void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_notify_response_user_callback && msg) {
on_nan_notify_response_user_callback(id, *msg);
}
}
std::function<void(const NanPublishRepliedInd&)> on_nan_event_publish_replied_user_callback;
void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
void onAsyncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
LOG(ERROR) << "onAsyncNanEventPublishReplied triggered";
}
std::function<void(const NanPublishTerminatedInd&)> on_nan_event_publish_terminated_user_callback;
void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_publish_terminated_user_callback && event) {
on_nan_event_publish_terminated_user_callback(*event);
}
}
std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
void onAysncNanEventMatch(NanMatchInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventMatch(NanMatchInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_match_user_callback && event) {
on_nan_event_match_user_callback(*event);
}
}
std::function<void(const NanMatchExpiredInd&)> on_nan_event_match_expired_user_callback;
void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventMatchExpired(NanMatchExpiredInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_match_expired_user_callback && event) {
on_nan_event_match_expired_user_callback(*event);
}
@@ -222,95 +222,95 @@ void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
std::function<void(const NanSubscribeTerminatedInd&)>
on_nan_event_subscribe_terminated_user_callback;
void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_subscribe_terminated_user_callback && event) {
on_nan_event_subscribe_terminated_user_callback(*event);
}
}
std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
void onAysncNanEventFollowup(NanFollowupInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventFollowup(NanFollowupInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_followup_user_callback && event) {
on_nan_event_followup_user_callback(*event);
}
}
std::function<void(const NanDiscEngEventInd&)> on_nan_event_disc_eng_event_user_callback;
void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_disc_eng_event_user_callback && event) {
on_nan_event_disc_eng_event_user_callback(*event);
}
}
std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
void onAysncNanEventDisabled(NanDisabledInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventDisabled(NanDisabledInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_disabled_user_callback && event) {
on_nan_event_disabled_user_callback(*event);
}
}
std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
void onAysncNanEventTca(NanTCAInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventTca(NanTCAInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_tca_user_callback && event) {
on_nan_event_tca_user_callback(*event);
}
}
std::function<void(const NanBeaconSdfPayloadInd&)> on_nan_event_beacon_sdf_payload_user_callback;
void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_beacon_sdf_payload_user_callback && event) {
on_nan_event_beacon_sdf_payload_user_callback(*event);
}
}
std::function<void(const NanDataPathRequestInd&)> on_nan_event_data_path_request_user_callback;
void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventDataPathRequest(NanDataPathRequestInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_data_path_request_user_callback && event) {
on_nan_event_data_path_request_user_callback(*event);
}
}
std::function<void(const NanDataPathConfirmInd&)> on_nan_event_data_path_confirm_user_callback;
void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_data_path_confirm_user_callback && event) {
on_nan_event_data_path_confirm_user_callback(*event);
}
}
std::function<void(const NanDataPathEndInd&)> on_nan_event_data_path_end_user_callback;
void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventDataPathEnd(NanDataPathEndInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_data_path_end_user_callback && event) {
on_nan_event_data_path_end_user_callback(*event);
}
}
std::function<void(const NanTransmitFollowupInd&)> on_nan_event_transmit_follow_up_user_callback;
void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_transmit_follow_up_user_callback && event) {
on_nan_event_transmit_follow_up_user_callback(*event);
}
}
std::function<void(const NanRangeRequestInd&)> on_nan_event_range_request_user_callback;
void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventRangeRequest(NanRangeRequestInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_range_request_user_callback && event) {
on_nan_event_range_request_user_callback(*event);
}
}
std::function<void(const NanRangeReportInd&)> on_nan_event_range_report_user_callback;
void onAysncNanEventRangeReport(NanRangeReportInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
void onAsyncNanEventRangeReport(NanRangeReportInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_range_report_user_callback && event) {
on_nan_event_range_report_user_callback(*event);
}
@@ -318,7 +318,7 @@ void onAysncNanEventRangeReport(NanRangeReportInd* event) {
std::function<void(const NanDataPathScheduleUpdateInd&)> on_nan_event_schedule_update_user_callback;
void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_schedule_update_user_callback && event) {
on_nan_event_schedule_update_user_callback(*event);
}
@@ -327,7 +327,7 @@ void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
// Callbacks for the various TWT operations.
std::function<void(const TwtSetupResponse&)> on_twt_event_setup_response_callback;
void onAsyncTwtEventSetupResponse(TwtSetupResponse* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_twt_event_setup_response_callback && event) {
on_twt_event_setup_response_callback(*event);
}
@@ -335,7 +335,7 @@ void onAsyncTwtEventSetupResponse(TwtSetupResponse* event) {
std::function<void(const TwtTeardownCompletion&)> on_twt_event_teardown_completion_callback;
void onAsyncTwtEventTeardownCompletion(TwtTeardownCompletion* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_twt_event_teardown_completion_callback && event) {
on_twt_event_teardown_completion_callback(*event);
}
@@ -343,7 +343,7 @@ void onAsyncTwtEventTeardownCompletion(TwtTeardownCompletion* event) {
std::function<void(const TwtInfoFrameReceived&)> on_twt_event_info_frame_received_callback;
void onAsyncTwtEventInfoFrameReceived(TwtInfoFrameReceived* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_twt_event_info_frame_received_callback && event) {
on_twt_event_info_frame_received_callback(*event);
}
@@ -351,7 +351,7 @@ void onAsyncTwtEventInfoFrameReceived(TwtInfoFrameReceived* event) {
std::function<void(const TwtDeviceNotify&)> on_twt_event_device_notify_callback;
void onAsyncTwtEventDeviceNotify(TwtDeviceNotify* event) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_twt_event_device_notify_callback && event) {
on_twt_event_device_notify_callback(*event);
}
@@ -360,7 +360,7 @@ void onAsyncTwtEventDeviceNotify(TwtDeviceNotify* event) {
// Callback to report current CHRE NAN state
std::function<void(chre_nan_rtt_state)> on_chre_nan_rtt_internal_callback;
void onAsyncChreNanRttState(chre_nan_rtt_state state) {
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_chre_nan_rtt_internal_callback) {
on_chre_nan_rtt_internal_callback(state);
}
@@ -376,7 +376,7 @@ void onSyncCachedScanResults(wifi_cached_scan_report* cache_report) {
// End of the free-standing "C" style callbacks.
WifiLegacyHal::WifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
WifiLegacyHal::WifiLegacyHal(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary)
: global_func_table_(fn),
global_handle_(nullptr),
@@ -769,7 +769,7 @@ wifi_error WifiLegacyHal::startRssiMonitoring(
if (!bssid_ptr) {
return;
}
std::array<uint8_t, 6> bssid_arr;
std::array<uint8_t, ETH_ALEN> bssid_arr;
// |bssid_ptr| pointer is assumed to have 6 bytes for the mac
// address.
std::copy(bssid_ptr, bssid_ptr + 6, std::begin(bssid_arr));
@@ -820,12 +820,12 @@ wifi_error WifiLegacyHal::configureNdOffload(const std::string& iface_name, bool
return global_func_table_.wifi_configure_nd_offload(getIfaceHandle(iface_name), enable);
}
wifi_error WifiLegacyHal::startSendingOffloadedPacket(const std::string& iface_name,
uint32_t cmd_id, uint16_t ether_type,
wifi_error WifiLegacyHal::startSendingOffloadedPacket(const std::string& iface_name, int32_t cmd_id,
uint16_t ether_type,
const std::vector<uint8_t>& ip_packet_data,
const std::array<uint8_t, 6>& src_address,
const std::array<uint8_t, 6>& dst_address,
uint32_t period_in_ms) {
int32_t period_in_ms) {
std::vector<uint8_t> ip_packet_data_internal(ip_packet_data);
std::vector<uint8_t> src_address_internal(src_address.data(),
src_address.data() + src_address.size());
@@ -1120,14 +1120,15 @@ wifi_error WifiLegacyHal::startRttRangeRequest(
wifi_error WifiLegacyHal::cancelRttRangeRequest(
const std::string& iface_name, wifi_request_id id,
const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
const std::vector<std::array<uint8_t, ETH_ALEN>>& mac_addrs) {
if (!on_rtt_results_internal_callback) {
return WIFI_ERROR_NOT_AVAILABLE;
}
static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>), "MAC address size mismatch");
static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, ETH_ALEN>),
"MAC address size mismatch");
// TODO: How do we handle partial cancels (i.e only a subset of enabled mac
// addressed are cancelled).
std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
std::vector<std::array<uint8_t, ETH_ALEN>> mac_addrs_internal(mac_addrs);
wifi_error status = global_func_table_.wifi_rtt_range_cancel(
id, getIfaceHandle(iface_name), mac_addrs.size(),
reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
@@ -1202,14 +1203,14 @@ wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(const std::string& iface_n
return global_func_table_.wifi_nan_register_handler(
getIfaceHandle(iface_name),
{onAysncNanNotifyResponse, onAysncNanEventPublishReplied,
onAysncNanEventPublishTerminated, onAysncNanEventMatch, onAysncNanEventMatchExpired,
onAysncNanEventSubscribeTerminated, onAysncNanEventFollowup,
onAysncNanEventDiscEngEvent, onAysncNanEventDisabled, onAysncNanEventTca,
onAysncNanEventBeaconSdfPayload, onAysncNanEventDataPathRequest,
onAysncNanEventDataPathConfirm, onAysncNanEventDataPathEnd,
onAysncNanEventTransmitFollowUp, onAysncNanEventRangeRequest,
onAysncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
{onAsyncNanNotifyResponse, onAsyncNanEventPublishReplied,
onAsyncNanEventPublishTerminated, onAsyncNanEventMatch, onAsyncNanEventMatchExpired,
onAsyncNanEventSubscribeTerminated, onAsyncNanEventFollowup,
onAsyncNanEventDiscEngEvent, onAsyncNanEventDisabled, onAsyncNanEventTca,
onAsyncNanEventBeaconSdfPayload, onAsyncNanEventDataPathRequest,
onAsyncNanEventDataPathConfirm, onAsyncNanEventDataPathEnd,
onAsyncNanEventTransmitFollowUp, onAsyncNanEventRangeRequest,
onAsyncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
}
wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name, transaction_id id,
@@ -1340,7 +1341,7 @@ wifi_error WifiLegacyHal::nanDataEnd(const std::string& iface_name, transaction_
}
wifi_error WifiLegacyHal::setCountryCode(const std::string& iface_name,
std::array<int8_t, 2> code) {
const std::array<uint8_t, 2> code) {
std::string code_str(code.data(), code.data() + code.size());
return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name), code_str.c_str());
}
@@ -1384,7 +1385,7 @@ wifi_interface_handle WifiLegacyHal::getIfaceHandle(const std::string& iface_nam
void WifiLegacyHal::runEventLoop() {
LOG(DEBUG) << "Starting legacy HAL event loop";
global_func_table_.wifi_event_loop(global_handle_);
const auto lock = hidl_sync_util::acquireGlobalLock();
const auto lock = aidl_sync_util::acquireGlobalLock();
if (!awaiting_event_loop_termination_) {
LOG(FATAL) << "Legacy HAL event loop terminated, but HAL was not stopping";
}
@@ -1647,8 +1648,7 @@ void WifiLegacyHal::invalidate() {
}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

45
wifi/1.6/default/wifi_legacy_hal.h → wifi/aidl/default/wifi_legacy_hal.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -17,22 +17,22 @@
#ifndef WIFI_LEGACY_HAL_H_
#define WIFI_LEGACY_HAL_H_
#include <condition_variable>
#include <functional>
#include <map>
#include <thread>
#include <vector>
#include <hardware_legacy/wifi_hal.h>
#include <wifi_system/interface_tool.h>
#include <condition_variable>
#include <functional>
#include <map>
#include <mutex>
#include <thread>
#include <vector>
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
// This is in a separate namespace to prevent typename conflicts between
// the legacy HAL types and the HIDL interface types.
// the legacy HAL types and the AIDL interface types.
namespace legacy_hal {
// Import all the types defined inside the legacy HAL header files into this
// namespace.
@@ -411,7 +411,7 @@ using on_gscan_results_callback =
// Invoked when the rssi value breaches the thresholds set.
using on_rssi_threshold_breached_callback =
std::function<void(wifi_request_id, std::array<uint8_t, 6>, int8_t)>;
std::function<void(wifi_request_id, std::array<uint8_t, ETH_ALEN>, int8_t)>;
// Callback for RTT range request results.
// Rtt results contain IE info and are hence passed by reference, to
@@ -481,8 +481,8 @@ struct CachedScanResultsCallbackHandlers {
*/
class WifiLegacyHal {
public:
WifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool, const wifi_hal_fn& fn,
bool is_primary);
WifiLegacyHal(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary);
virtual ~WifiLegacyHal() = default;
// Initialize the legacy HAL function table.
@@ -521,7 +521,7 @@ class WifiLegacyHal {
// |on_results_user_callback| on success.
// b) |WIFI_SCAN_FAILED| scan event or failure to retrieve cached scan
// results
// triggers the externally provided |on_failure_user_callback|.
// Triggers the externally provided |on_failure_user_callback|.
// c) Full scan result event triggers the externally provided
// |on_full_result_user_callback|.
wifi_error startGscan(const std::string& iface_name, wifi_request_id id,
@@ -547,12 +547,12 @@ class WifiLegacyHal {
wifi_error configureRoaming(const std::string& iface_name, const wifi_roaming_config& config);
wifi_error enableFirmwareRoaming(const std::string& iface_name, fw_roaming_state_t state);
wifi_error configureNdOffload(const std::string& iface_name, bool enable);
wifi_error startSendingOffloadedPacket(const std::string& iface_name, uint32_t cmd_id,
wifi_error startSendingOffloadedPacket(const std::string& iface_name, int32_t cmd_id,
uint16_t ether_type,
const std::vector<uint8_t>& ip_packet_data,
const std::array<uint8_t, 6>& src_address,
const std::array<uint8_t, 6>& dst_address,
uint32_t period_in_ms);
int32_t period_in_ms);
wifi_error stopSendingOffloadedPacket(const std::string& iface_name, uint32_t cmd_id);
virtual wifi_error selectTxPowerScenario(const std::string& iface_name,
wifi_power_scenario scenario);
@@ -591,7 +591,7 @@ class WifiLegacyHal {
const std::vector<wifi_rtt_config>& rtt_configs,
const on_rtt_results_callback& on_results_callback);
wifi_error cancelRttRangeRequest(const std::string& iface_name, wifi_request_id id,
const std::vector<std::array<uint8_t, 6>>& mac_addrs);
const std::vector<std::array<uint8_t, ETH_ALEN>>& mac_addrs);
std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities(const std::string& iface_name);
std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo(const std::string& iface_name);
wifi_error enableRttResponder(const std::string& iface_name, wifi_request_id id,
@@ -638,9 +638,9 @@ class WifiLegacyHal {
const NanDataPathIndicationResponse& msg);
wifi_error nanDataEnd(const std::string& iface_name, transaction_id id, uint32_t ndpInstanceId);
// AP functions.
wifi_error setCountryCode(const std::string& iface_name, std::array<int8_t, 2> code);
wifi_error setCountryCode(const std::string& iface_name, const std::array<uint8_t, 2> code);
// interface functions.
// Interface functions.
virtual wifi_error createVirtualInterface(const std::string& ifname,
wifi_interface_type iftype);
virtual wifi_error deleteVirtualInterface(const std::string& ifname);
@@ -721,8 +721,8 @@ class WifiLegacyHal {
std::condition_variable_any stop_wait_cv_;
// Flag to indicate if the legacy HAL has been started.
bool is_started_;
std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
// flag to indicate if this HAL is for the primary chip. This is used
std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
// Flag to indicate if this HAL is for the primary chip. This is used
// in order to avoid some hard-coded behavior used with older HALs,
// such as bring wlan0 interface up/down on start/stop HAL.
// it may be removed once vendor HALs are updated.
@@ -730,10 +730,9 @@ class WifiLegacyHal {
};
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_LEGACY_HAL_H_

18
wifi/1.6/default/wifi_legacy_hal_factory.cpp → wifi/aidl/default/wifi_legacy_hal_factory.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 The Android Open Source Project
* 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.
@@ -14,17 +14,17 @@
* limitations under the License.
*/
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "wifi_legacy_hal_factory.h"
#include <android-base/logging.h>
#include <dirent.h>
#include <dlfcn.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xmlmemory.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "wifi_legacy_hal_factory.h"
#include "wifi_legacy_hal_stubs.h"
namespace {
@@ -59,15 +59,14 @@ bool isFileExtension(const char* name, const char* ext) {
}
}; // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
WifiLegacyHalFactory::WifiLegacyHalFactory(
const std::weak_ptr<wifi_system::InterfaceTool> iface_tool)
const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool)
: iface_tool_(iface_tool) {}
std::vector<std::shared_ptr<WifiLegacyHal>> WifiLegacyHalFactory::getHals() {
@@ -247,8 +246,7 @@ out_err:
}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

14
wifi/1.6/default/wifi_legacy_hal_factory.h → wifi/aidl/default/wifi_legacy_hal_factory.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 The Android Open Source Project
* 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.
@@ -21,20 +21,19 @@
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
// This is in a separate namespace to prevent typename conflicts between
// the legacy HAL types and the HIDL interface types.
// the legacy HAL types and the AIDL interface types.
namespace legacy_hal {
/**
* Class that creates WifiLegacyHal objects for vendor HALs in the system.
*/
class WifiLegacyHalFactory {
public:
WifiLegacyHalFactory(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool);
WifiLegacyHalFactory(const std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool);
virtual ~WifiLegacyHalFactory() = default;
std::vector<std::shared_ptr<WifiLegacyHal>> getHals();
@@ -51,16 +50,15 @@ class WifiLegacyHalFactory {
bool initLinkedHalFunctionTable(wifi_hal_fn* hal_fn);
bool loadVendorHalLib(const std::string& path, wifi_hal_lib_desc& desc);
std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
std::weak_ptr<::android::wifi_system::InterfaceTool> iface_tool_;
std::vector<wifi_hal_lib_desc> descs_;
std::vector<std::shared_ptr<WifiLegacyHal>> legacy_hals_;
};
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_LEGACY_HAL_FACTORY_H_

9
wifi/1.6/default/wifi_legacy_hal_stubs.cpp → wifi/aidl/default/wifi_legacy_hal_stubs.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -17,11 +17,10 @@
#include "wifi_legacy_hal_stubs.h"
// TODO: Remove these stubs from HalTool in libwifi-system.
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
template <typename>
struct stubFunction;
@@ -170,9 +169,9 @@ bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn) {
populateStubFor(&hal_fn->wifi_get_cached_scan_results);
return true;
}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

8
wifi/1.6/default/wifi_legacy_hal_stubs.h → wifi/aidl/default/wifi_legacy_hal_stubs.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -19,19 +19,17 @@
#include <hardware_legacy/wifi_hal.h>
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn);
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_LEGACY_HAL_STUBS_H_

19
wifi/1.6/default/wifi_mode_controller.cpp → wifi/aidl/default/wifi_mode_controller.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -14,16 +14,16 @@
* limitations under the License.
*/
#include "wifi_mode_controller.h"
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <private/android_filesystem_config.h>
#include "wifi_mode_controller.h"
using android::hardware::wifi::V1_0::IfaceType;
namespace {
using aidl::android::hardware::wifi::IfaceType;
using android::wifi_hal::DriverTool;
namespace {
int convertIfaceTypeToFirmwareMode(IfaceType type) {
int mode;
switch (type) {
@@ -33,7 +33,7 @@ int convertIfaceTypeToFirmwareMode(IfaceType type) {
case IfaceType::P2P:
mode = DriverTool::kFirmwareModeP2p;
break;
case IfaceType::NAN:
case IfaceType::NAN_IFACE:
// NAN is exposed in STA mode currently.
mode = DriverTool::kFirmwareModeSta;
break;
@@ -45,11 +45,10 @@ int convertIfaceTypeToFirmwareMode(IfaceType type) {
}
} // namespace
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
WifiModeController::WifiModeController() : driver_tool_(new DriverTool) {}
@@ -81,9 +80,9 @@ bool WifiModeController::deinitialize() {
}
return true;
}
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

14
wifi/1.6/default/wifi_mode_controller.h → wifi/aidl/default/wifi_mode_controller.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -17,17 +17,14 @@
#ifndef WIFI_MODE_CONTROLLER_H_
#define WIFI_MODE_CONTROLLER_H_
#include <aidl/android/hardware/wifi/IWifi.h>
#include <wifi_hal/driver_tool.h>
#include <android/hardware/wifi/1.0/IWifi.h>
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
using namespace android::hardware::wifi::V1_0;
/**
* Class that encapsulates all firmware mode configuration.
@@ -50,14 +47,13 @@ class WifiModeController {
virtual bool deinitialize();
private:
std::unique_ptr<wifi_hal::DriverTool> driver_tool_;
std::unique_ptr<::android::wifi_hal::DriverTool> driver_tool_;
};
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_MODE_CONTROLLER_H_

751
wifi/aidl/default/wifi_nan_iface.cpp Normal file
View File

@@ -0,0 +1,751 @@
/*
* 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_nan_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;
WifiNanIface::WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
: ifname_(ifname),
is_dedicated_iface_(is_dedicated_iface),
legacy_hal_(legacy_hal),
iface_util_(iface_util),
is_valid_(true) {}
std::shared_ptr<WifiNanIface> WifiNanIface::create(
const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) {
std::shared_ptr<WifiNanIface> ptr = ndk::SharedRefBase::make<WifiNanIface>(
ifname, is_dedicated_iface, legacy_hal, iface_util);
if (is_dedicated_iface) {
// If using a dedicated iface, set the iface up first.
if (!iface_util.lock()->setUpState(ifname, true)) {
// Fatal failure, invalidate the iface object.
ptr->invalidate();
return nullptr;
}
}
std::weak_ptr<WifiNanIface> weak_ptr_this(ptr);
ptr->setWeakPtr(weak_ptr_this);
ptr->registerCallbackHandlers();
return ptr;
}
void WifiNanIface::registerCallbackHandlers() {
// Register all the callbacks here. These should be valid for the lifetime
// of the object. Whenever the mode changes legacy HAL will remove
// all of these callbacks.
legacy_hal::NanCallbackHandlers callback_handlers;
std::weak_ptr<WifiNanIface> weak_ptr_this = weak_ptr_this_;
// Callback for response.
callback_handlers.on_notify_response = [weak_ptr_this](legacy_hal::transaction_id id,
const legacy_hal::NanResponseMsg& msg) {
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;
}
NanStatus nanStatus;
if (!aidl_struct_util::convertLegacyNanResponseHeaderToAidl(msg, &nanStatus)) {
LOG(ERROR) << "Failed to convert nan response header";
return;
}
switch (msg.response_type) {
case legacy_hal::NAN_RESPONSE_ENABLED: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyEnableResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_DISABLED: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyDisableResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_PUBLISH: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyStartPublishResponse(id, nanStatus,
msg.body.publish_response.publish_id)
.isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyStopPublishResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyTransmitFollowupResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_SUBSCRIBE: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyStartSubscribeResponse(
id, nanStatus, msg.body.subscribe_response.subscribe_id)
.isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyStopSubscribeResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_CONFIG: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyConfigResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_GET_CAPABILITIES: {
NanCapabilities aidl_struct;
if (!aidl_struct_util::convertLegacyNanCapabilitiesResponseToAidl(
msg.body.nan_capabilities, &aidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyCapabilitiesResponse(id, nanStatus, aidl_struct).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_DP_INTERFACE_CREATE: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyCreateDataInterfaceResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_DP_INTERFACE_DELETE: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyDeleteDataInterfaceResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_DP_INITIATOR_RESPONSE: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyInitiateDataPathResponse(
id, nanStatus,
msg.body.data_request_response.ndp_instance_id)
.isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_DP_RESPONDER_RESPONSE: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyRespondToDataPathIndicationResponse(id, nanStatus)
.isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_DP_END: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->notifyTerminateDataPathResponse(id, nanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD:
/* fall through */
case legacy_hal::NAN_RESPONSE_TCA:
/* fall through */
case legacy_hal::NAN_RESPONSE_STATS:
/* fall through */
case legacy_hal::NAN_RESPONSE_ERROR:
/* fall through */
default:
LOG(ERROR) << "Unknown or unhandled response type: " << msg.response_type;
return;
}
};
callback_handlers.on_event_disc_eng_event = [weak_ptr_this](
const legacy_hal::NanDiscEngEventInd& msg) {
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;
}
NanClusterEventInd aidl_struct;
// event types defined identically - hence can be cast
aidl_struct.eventType = (NanClusterEventType)msg.event_type;
aidl_struct.addr = std::array<uint8_t, 6>();
std::copy(msg.data.mac_addr.addr, msg.data.mac_addr.addr + 6, std::begin(aidl_struct.addr));
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventClusterEvent(aidl_struct).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_disabled = [weak_ptr_this](const legacy_hal::NanDisabledInd& msg) {
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;
}
NanStatus status;
aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason, sizeof(msg.nan_reason),
&status);
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventDisabled(status).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_publish_terminated =
[weak_ptr_this](const legacy_hal::NanPublishTerminatedInd& msg) {
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;
}
NanStatus status;
aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason,
sizeof(msg.nan_reason), &status);
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventPublishTerminated(msg.publish_id, status).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_subscribe_terminated =
[weak_ptr_this](const legacy_hal::NanSubscribeTerminatedInd& msg) {
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;
}
NanStatus status;
aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason,
sizeof(msg.nan_reason), &status);
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventSubscribeTerminated(msg.subscribe_id, status).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_match = [weak_ptr_this](const legacy_hal::NanMatchInd& msg) {
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;
}
NanMatchInd aidl_struct;
if (!aidl_struct_util::convertLegacyNanMatchIndToAidl(msg, &aidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventMatch(aidl_struct).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_match_expired = [weak_ptr_this](
const legacy_hal::NanMatchExpiredInd& msg) {
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->eventMatchExpired(msg.publish_subscribe_id, msg.requestor_instance_id)
.isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_followup = [weak_ptr_this](const legacy_hal::NanFollowupInd& msg) {
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;
}
NanFollowupReceivedInd aidl_struct;
if (!aidl_struct_util::convertLegacyNanFollowupIndToAidl(msg, &aidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventFollowupReceived(aidl_struct).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_transmit_follow_up =
[weak_ptr_this](const legacy_hal::NanTransmitFollowupInd& msg) {
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;
}
NanStatus status;
aidl_struct_util::convertToNanStatus(msg.reason, msg.nan_reason,
sizeof(msg.nan_reason), &status);
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventTransmitFollowup(msg.id, status).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_data_path_request =
[weak_ptr_this](const legacy_hal::NanDataPathRequestInd& msg) {
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;
}
NanDataPathRequestInd aidl_struct;
if (!aidl_struct_util::convertLegacyNanDataPathRequestIndToAidl(msg,
&aidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventDataPathRequest(aidl_struct).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_data_path_confirm =
[weak_ptr_this](const legacy_hal::NanDataPathConfirmInd& msg) {
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;
}
NanDataPathConfirmInd aidl_struct;
if (!aidl_struct_util::convertLegacyNanDataPathConfirmIndToAidl(msg,
&aidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventDataPathConfirm(aidl_struct).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
callback_handlers.on_event_data_path_end =
[weak_ptr_this](const legacy_hal::NanDataPathEndInd& msg) {
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()) {
for (int i = 0; i < msg.num_ndp_instances; ++i) {
if (!callback->eventDataPathTerminated(msg.ndp_instance_id[i]).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
}
};
callback_handlers.on_event_beacon_sdf_payload =
[](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) {
LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called";
};
callback_handlers.on_event_range_request = [](const legacy_hal::NanRangeRequestInd& /* msg */) {
LOG(ERROR) << "on_event_range_request - should not be called";
};
callback_handlers.on_event_range_report = [](const legacy_hal::NanRangeReportInd& /* msg */) {
LOG(ERROR) << "on_event_range_report - should not be called";
};
callback_handlers.on_event_schedule_update =
[weak_ptr_this](const legacy_hal::NanDataPathScheduleUpdateInd& msg) {
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;
}
NanDataPathScheduleUpdateInd aidl_struct;
if (!aidl_struct_util::convertLegacyNanDataPathScheduleUpdateIndToAidl(
msg, &aidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventDataPathScheduleUpdate(aidl_struct).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanRegisterCallbackHandlers(ifname_, callback_handlers);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
LOG(ERROR) << "Failed to register nan callbacks. Invalidating object";
invalidate();
}
// Register for iface state toggle events.
iface_util::IfaceEventHandlers event_handlers = {};
event_handlers.on_state_toggle_off_on = [weak_ptr_this](const std::string& /* iface_name */) {
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;
}
// Tell framework that NAN has been disabled.
NanStatus status = {NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventDisabled(status).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
iface_util_.lock()->registerIfaceEventHandlers(ifname_, event_handlers);
}
void WifiNanIface::setWeakPtr(std::weak_ptr<WifiNanIface> ptr) {
weak_ptr_this_ = ptr;
}
void WifiNanIface::invalidate() {
if (!isValid()) {
return;
}
// send commands to HAL to actually disable and destroy interfaces
legacy_hal_.lock()->nanDisableRequest(ifname_, 0xFFFF);
legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFE, "aware_data0");
legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFD, "aware_data1");
iface_util_.lock()->unregisterIfaceEventHandlers(ifname_);
legacy_hal_.reset();
event_cb_handler_.invalidate();
is_valid_ = false;
if (is_dedicated_iface_) {
// If using a dedicated iface, set the iface down.
iface_util_.lock()->setUpState(ifname_, false);
}
}
bool WifiNanIface::isValid() {
return is_valid_;
}
std::string WifiNanIface::getName() {
return ifname_;
}
std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks() {
LOG(ERROR) << "Using original getEventCallbacks";
return event_cb_handler_.getCallbacks();
}
ndk::ScopedAStatus WifiNanIface::getName(std::string* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::getNameInternal, _aidl_return);
}
ndk::ScopedAStatus WifiNanIface::registerEventCallback(
const std::shared_ptr<IWifiNanIfaceEventCallback>& callback) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::registerEventCallbackInternal, callback);
}
ndk::ScopedAStatus WifiNanIface::getCapabilitiesRequest(char16_t in_cmdId) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::getCapabilitiesRequestInternal, in_cmdId);
}
ndk::ScopedAStatus WifiNanIface::enableRequest(char16_t in_cmdId, const NanEnableRequest& in_msg1,
const NanConfigRequestSupplemental& in_msg2) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::enableRequestInternal, in_cmdId, in_msg1, in_msg2);
}
ndk::ScopedAStatus WifiNanIface::configRequest(char16_t in_cmdId, const NanConfigRequest& in_msg1,
const NanConfigRequestSupplemental& in_msg2) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::configRequestInternal, in_cmdId, in_msg1, in_msg2);
}
ndk::ScopedAStatus WifiNanIface::disableRequest(char16_t in_cmdId) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::disableRequestInternal, in_cmdId);
}
ndk::ScopedAStatus WifiNanIface::startPublishRequest(char16_t in_cmdId,
const NanPublishRequest& in_msg) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::startPublishRequestInternal, in_cmdId, in_msg);
}
ndk::ScopedAStatus WifiNanIface::stopPublishRequest(char16_t in_cmdId, int8_t in_sessionId) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::stopPublishRequestInternal, in_cmdId, in_sessionId);
}
ndk::ScopedAStatus WifiNanIface::startSubscribeRequest(char16_t in_cmdId,
const NanSubscribeRequest& in_msg) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::startSubscribeRequestInternal, in_cmdId, in_msg);
}
ndk::ScopedAStatus WifiNanIface::stopSubscribeRequest(char16_t in_cmdId, int8_t in_sessionId) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::stopSubscribeRequestInternal, in_cmdId, in_sessionId);
}
ndk::ScopedAStatus WifiNanIface::transmitFollowupRequest(char16_t in_cmdId,
const NanTransmitFollowupRequest& in_msg) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::transmitFollowupRequestInternal, in_cmdId, in_msg);
}
ndk::ScopedAStatus WifiNanIface::createDataInterfaceRequest(char16_t in_cmdId,
const std::string& in_ifaceName) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::createDataInterfaceRequestInternal, in_cmdId,
in_ifaceName);
}
ndk::ScopedAStatus WifiNanIface::deleteDataInterfaceRequest(char16_t in_cmdId,
const std::string& in_ifaceName) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::deleteDataInterfaceRequestInternal, in_cmdId,
in_ifaceName);
}
ndk::ScopedAStatus WifiNanIface::initiateDataPathRequest(char16_t in_cmdId,
const NanInitiateDataPathRequest& in_msg) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::initiateDataPathRequestInternal, in_cmdId, in_msg);
}
ndk::ScopedAStatus WifiNanIface::respondToDataPathIndicationRequest(
char16_t in_cmdId, const NanRespondToDataPathIndicationRequest& in_msg) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::respondToDataPathIndicationRequestInternal, in_cmdId,
in_msg);
}
ndk::ScopedAStatus WifiNanIface::terminateDataPathRequest(char16_t in_cmdId,
int32_t in_ndpInstanceId) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::terminateDataPathRequestInternal, in_cmdId,
in_ndpInstanceId);
}
std::pair<std::string, ndk::ScopedAStatus> WifiNanIface::getNameInternal() {
return {ifname_, ndk::ScopedAStatus::ok()};
}
ndk::ScopedAStatus WifiNanIface::registerEventCallbackInternal(
const std::shared_ptr<IWifiNanIfaceEventCallback>& callback) {
if (!event_cb_handler_.addCallback(callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus WifiNanIface::getCapabilitiesRequestInternal(char16_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::enableRequestInternal(char16_t cmd_id,
const NanEnableRequest& msg1,
const NanConfigRequestSupplemental& msg2) {
legacy_hal::NanEnableRequest legacy_msg;
if (!aidl_struct_util::convertAidlNanEnableRequestToLegacy(msg1, msg2, &legacy_msg)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanEnableRequest(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::configRequestInternal(char16_t cmd_id,
const NanConfigRequest& msg1,
const NanConfigRequestSupplemental& msg2) {
legacy_hal::NanConfigRequest legacy_msg;
if (!aidl_struct_util::convertAidlNanConfigRequestToLegacy(msg1, msg2, &legacy_msg)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanConfigRequest(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::disableRequestInternal(char16_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::startPublishRequestInternal(char16_t cmd_id,
const NanPublishRequest& msg) {
legacy_hal::NanPublishRequest legacy_msg;
if (!aidl_struct_util::convertAidlNanPublishRequestToLegacy(msg, &legacy_msg)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanPublishRequest(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::stopPublishRequestInternal(char16_t cmd_id, int8_t sessionId) {
legacy_hal::NanPublishCancelRequest legacy_msg;
legacy_msg.publish_id = sessionId;
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanPublishCancelRequest(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::startSubscribeRequestInternal(char16_t cmd_id,
const NanSubscribeRequest& msg) {
legacy_hal::NanSubscribeRequest legacy_msg;
if (!aidl_struct_util::convertAidlNanSubscribeRequestToLegacy(msg, &legacy_msg)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanSubscribeRequest(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::stopSubscribeRequestInternal(char16_t cmd_id, int8_t sessionId) {
legacy_hal::NanSubscribeCancelRequest legacy_msg;
legacy_msg.subscribe_id = sessionId;
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanSubscribeCancelRequest(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::transmitFollowupRequestInternal(
char16_t cmd_id, const NanTransmitFollowupRequest& msg) {
legacy_hal::NanTransmitFollowupRequest legacy_msg;
if (!aidl_struct_util::convertAidlNanTransmitFollowupRequestToLegacy(msg, &legacy_msg)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanTransmitFollowupRequest(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::createDataInterfaceRequestInternal(char16_t cmd_id,
const std::string& iface_name) {
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanDataInterfaceCreate(ifname_, cmd_id, iface_name);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::deleteDataInterfaceRequestInternal(char16_t cmd_id,
const std::string& iface_name) {
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, cmd_id, iface_name);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::initiateDataPathRequestInternal(
char16_t cmd_id, const NanInitiateDataPathRequest& msg) {
legacy_hal::NanDataPathInitiatorRequest legacy_msg;
if (!aidl_struct_util::convertAidlNanDataPathInitiatorRequestToLegacy(msg, &legacy_msg)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanDataRequestInitiator(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::respondToDataPathIndicationRequestInternal(
char16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) {
legacy_hal::NanDataPathIndicationResponse legacy_msg;
if (!aidl_struct_util::convertAidlNanDataPathIndicationResponseToLegacy(msg, &legacy_msg)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanDataIndicationResponse(ifname_, cmd_id, legacy_msg);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::terminateDataPathRequestInternal(char16_t cmd_id,
int32_t ndpInstanceId) {
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId);
return createWifiStatusFromLegacyError(legacy_status);
}
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

134
wifi/aidl/default/wifi_nan_iface.h Normal file
View File

@@ -0,0 +1,134 @@
/*
* 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.
*/
#ifndef WIFI_NAN_IFACE_H_
#define WIFI_NAN_IFACE_H_
#include <aidl/android/hardware/wifi/BnWifiNanIface.h>
#include <aidl/android/hardware/wifi/IWifiNanIfaceEventCallback.h>
#include <android-base/macros.h>
#include "aidl_callback_util.h"
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
/**
* AIDL interface object used to control a NAN Iface instance.
*/
class WifiNanIface : public BnWifiNanIface {
public:
WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Factory method - use instead of default constructor.
static std::shared_ptr<WifiNanIface> create(
const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::string getName();
// AIDL methods exposed.
ndk::ScopedAStatus getName(std::string* _aidl_return) override;
ndk::ScopedAStatus registerEventCallback(
const std::shared_ptr<IWifiNanIfaceEventCallback>& in_callback) override;
ndk::ScopedAStatus getCapabilitiesRequest(char16_t in_cmdId) override;
ndk::ScopedAStatus enableRequest(char16_t in_cmdId, const NanEnableRequest& in_msg1,
const NanConfigRequestSupplemental& in_msg2) override;
ndk::ScopedAStatus configRequest(char16_t in_cmdId, const NanConfigRequest& in_msg1,
const NanConfigRequestSupplemental& in_msg2) override;
ndk::ScopedAStatus disableRequest(char16_t in_cmdId) override;
ndk::ScopedAStatus startPublishRequest(char16_t in_cmdId,
const NanPublishRequest& in_msg) override;
ndk::ScopedAStatus stopPublishRequest(char16_t in_cmdId, int8_t in_sessionId) override;
ndk::ScopedAStatus startSubscribeRequest(char16_t in_cmdId,
const NanSubscribeRequest& in_msg) override;
ndk::ScopedAStatus stopSubscribeRequest(char16_t in_cmdId, int8_t in_sessionId) override;
ndk::ScopedAStatus transmitFollowupRequest(char16_t in_cmdId,
const NanTransmitFollowupRequest& in_msg) override;
ndk::ScopedAStatus createDataInterfaceRequest(char16_t in_cmdId,
const std::string& in_ifaceName) override;
ndk::ScopedAStatus deleteDataInterfaceRequest(char16_t in_cmdId,
const std::string& in_ifaceName) override;
ndk::ScopedAStatus initiateDataPathRequest(char16_t in_cmdId,
const NanInitiateDataPathRequest& in_msg) override;
ndk::ScopedAStatus respondToDataPathIndicationRequest(
char16_t in_cmdId, const NanRespondToDataPathIndicationRequest& in_msg) override;
ndk::ScopedAStatus terminateDataPathRequest(char16_t in_cmdId,
int32_t in_ndpInstanceId) override;
protected:
// Accessible to child class in the gTest suite.
void setWeakPtr(std::weak_ptr<WifiNanIface> ptr);
void registerCallbackHandlers();
private:
// Corresponding worker functions for the AIDL methods.
std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
ndk::ScopedAStatus registerEventCallbackInternal(
const std::shared_ptr<IWifiNanIfaceEventCallback>& callback);
ndk::ScopedAStatus getCapabilitiesRequestInternal(char16_t cmd_id);
ndk::ScopedAStatus enableRequestInternal(char16_t cmd_id, const NanEnableRequest& msg1,
const NanConfigRequestSupplemental& msg2);
ndk::ScopedAStatus configRequestInternal(char16_t cmd_id, const NanConfigRequest& msg1,
const NanConfigRequestSupplemental& msg2);
ndk::ScopedAStatus disableRequestInternal(char16_t cmd_id);
ndk::ScopedAStatus startPublishRequestInternal(char16_t cmd_id, const NanPublishRequest& msg);
ndk::ScopedAStatus stopPublishRequestInternal(char16_t cmd_id, int8_t sessionId);
ndk::ScopedAStatus startSubscribeRequestInternal(char16_t cmd_id,
const NanSubscribeRequest& msg);
ndk::ScopedAStatus stopSubscribeRequestInternal(char16_t cmd_id, int8_t sessionId);
ndk::ScopedAStatus transmitFollowupRequestInternal(char16_t cmd_id,
const NanTransmitFollowupRequest& msg);
ndk::ScopedAStatus createDataInterfaceRequestInternal(char16_t cmd_id,
const std::string& iface_name);
ndk::ScopedAStatus deleteDataInterfaceRequestInternal(char16_t cmd_id,
const std::string& iface_name);
ndk::ScopedAStatus initiateDataPathRequestInternal(char16_t cmd_id,
const NanInitiateDataPathRequest& msg);
ndk::ScopedAStatus respondToDataPathIndicationRequestInternal(
char16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg);
ndk::ScopedAStatus terminateDataPathRequestInternal(char16_t cmd_id, int32_t ndpInstanceId);
// Overridden in the gTest suite.
virtual std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> getEventCallbacks();
std::string ifname_;
bool is_dedicated_iface_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
std::weak_ptr<WifiNanIface> weak_ptr_this_;
aidl_callback_util::AidlCallbackHandler<IWifiNanIfaceEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
};
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_NAN_IFACE_H_

32
wifi/1.6/default/wifi_p2p_iface.cpp → wifi/aidl/default/wifi_p2p_iface.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -14,18 +14,18 @@
* limitations under the License.
*/
#include "wifi_p2p_iface.h"
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "wifi_p2p_iface.h"
#include "aidl_return_util.h"
#include "wifi_status_util.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
using aidl_return_util::validateAndCall;
WifiP2pIface::WifiP2pIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
@@ -44,26 +44,16 @@ std::string WifiP2pIface::getName() {
return ifname_;
}
Return<void> WifiP2pIface::getName(getName_cb hidl_status_cb) {
ndk::ScopedAStatus WifiP2pIface::getName(std::string* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiP2pIface::getNameInternal, hidl_status_cb);
&WifiP2pIface::getNameInternal, _aidl_return);
}
Return<void> WifiP2pIface::getType(getType_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiP2pIface::getTypeInternal, hidl_status_cb);
std::pair<std::string, ndk::ScopedAStatus> WifiP2pIface::getNameInternal() {
return {ifname_, ndk::ScopedAStatus::ok()};
}
std::pair<WifiStatus, std::string> WifiP2pIface::getNameInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
}
std::pair<WifiStatus, IfaceType> WifiP2pIface::getTypeInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::P2P};
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

25
wifi/1.6/default/wifi_p2p_iface.h → wifi/aidl/default/wifi_p2p_iface.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -17,22 +17,20 @@
#ifndef WIFI_P2P_IFACE_H_
#define WIFI_P2P_IFACE_H_
#include <aidl/android/hardware/wifi/BnWifiP2pIface.h>
#include <android-base/macros.h>
#include <android/hardware/wifi/1.0/IWifiP2pIface.h>
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
/**
* HIDL interface object used to control a P2P Iface instance.
* AIDL interface object used to control a P2P Iface instance.
*/
class WifiP2pIface : public V1_0::IWifiP2pIface {
class WifiP2pIface : public BnWifiP2pIface {
public:
WifiP2pIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
@@ -41,14 +39,12 @@ class WifiP2pIface : public V1_0::IWifiP2pIface {
bool isValid();
std::string getName();
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
// AIDL methods exposed.
ndk::ScopedAStatus getName(std::string* _aidl_return) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
// Corresponding worker functions for the AIDL methods.
std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
std::string ifname_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
@@ -57,10 +53,9 @@ class WifiP2pIface : public V1_0::IWifiP2pIface {
DISALLOW_COPY_AND_ASSIGN(WifiP2pIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_P2P_IFACE_H_

255
wifi/aidl/default/wifi_rtt_controller.cpp Normal file
View File

@@ -0,0 +1,255 @@
/*
* 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_rtt_controller.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;
WifiRttController::WifiRttController(const std::string& iface_name,
const std::shared_ptr<IWifiStaIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: ifname_(iface_name), bound_iface_(bound_iface), legacy_hal_(legacy_hal), is_valid_(true) {}
std::shared_ptr<WifiRttController> WifiRttController::create(
const std::string& iface_name, const std::shared_ptr<IWifiStaIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal) {
std::shared_ptr<WifiRttController> ptr =
ndk::SharedRefBase::make<WifiRttController>(iface_name, bound_iface, legacy_hal);
std::weak_ptr<WifiRttController> weak_ptr_this(ptr);
ptr->setWeakPtr(weak_ptr_this);
return ptr;
}
void WifiRttController::invalidate() {
legacy_hal_.reset();
event_callbacks_.clear();
is_valid_ = false;
};
bool WifiRttController::isValid() {
return is_valid_;
}
void WifiRttController::setWeakPtr(std::weak_ptr<WifiRttController> ptr) {
weak_ptr_this_ = ptr;
}
std::vector<std::shared_ptr<IWifiRttControllerEventCallback>>
WifiRttController::getEventCallbacks() {
return event_callbacks_;
}
std::string WifiRttController::getIfaceName() {
return ifname_;
}
ndk::ScopedAStatus WifiRttController::getBoundIface(std::shared_ptr<IWifiStaIface>* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getBoundIfaceInternal, _aidl_return);
}
ndk::ScopedAStatus WifiRttController::registerEventCallback(
const std::shared_ptr<IWifiRttControllerEventCallback>& callback) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::registerEventCallbackInternal, callback);
}
ndk::ScopedAStatus WifiRttController::rangeRequest(int32_t in_cmdId,
const std::vector<RttConfig>& in_rttConfigs) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeRequestInternal, in_cmdId, in_rttConfigs);
}
ndk::ScopedAStatus WifiRttController::rangeCancel(int32_t in_cmdId,
const std::vector<MacAddress>& in_addrs) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeCancelInternal, in_cmdId, in_addrs);
}
ndk::ScopedAStatus WifiRttController::getCapabilities(RttCapabilities* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getCapabilitiesInternal, _aidl_return);
}
ndk::ScopedAStatus WifiRttController::setLci(int32_t in_cmdId, const RttLciInformation& in_lci) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::setLciInternal, in_cmdId, in_lci);
}
ndk::ScopedAStatus WifiRttController::setLcr(int32_t in_cmdId, const RttLcrInformation& in_lcr) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::setLcrInternal, in_cmdId, in_lcr);
}
ndk::ScopedAStatus WifiRttController::getResponderInfo(RttResponder* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getResponderInfoInternal, _aidl_return);
}
ndk::ScopedAStatus WifiRttController::enableResponder(int32_t in_cmdId,
const WifiChannelInfo& in_channelHint,
int32_t in_maxDurationInSeconds,
const RttResponder& in_info) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::enableResponderInternal, in_cmdId, in_channelHint,
in_maxDurationInSeconds, in_info);
}
ndk::ScopedAStatus WifiRttController::disableResponder(int32_t in_cmdId) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::disableResponderInternal, in_cmdId);
}
std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus>
WifiRttController::getBoundIfaceInternal() {
return {bound_iface_, ndk::ScopedAStatus::ok()};
}
ndk::ScopedAStatus WifiRttController::registerEventCallbackInternal(
const std::shared_ptr<IWifiRttControllerEventCallback>& callback) {
event_callbacks_.emplace_back(callback);
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus WifiRttController::rangeRequestInternal(
int32_t cmd_id, const std::vector<RttConfig>& rtt_configs) {
std::vector<legacy_hal::wifi_rtt_config> legacy_configs;
if (!aidl_struct_util::convertAidlVectorOfRttConfigToLegacy(rtt_configs, &legacy_configs)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
std::weak_ptr<WifiRttController> weak_ptr_this = weak_ptr_this_;
const auto& on_results_callback =
[weak_ptr_this](legacy_hal::wifi_request_id id,
const std::vector<const legacy_hal::wifi_rtt_result*>& 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<RttResult> aidl_results;
if (!aidl_struct_util::convertLegacyVectorOfRttResultToAidl(results,
&aidl_results)) {
LOG(ERROR) << "Failed to convert rtt results to AIDL structs";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onResults(id, aidl_results).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequest(
ifname_, cmd_id, legacy_configs, on_results_callback);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiRttController::rangeCancelInternal(int32_t cmd_id,
const std::vector<MacAddress>& addrs) {
std::vector<std::array<uint8_t, ETH_ALEN>> legacy_addrs;
for (const auto& addr : addrs) {
std::array<uint8_t, ETH_ALEN> addr_array;
std::copy_n(addr.data.begin(), ETH_ALEN, addr_array.begin());
legacy_addrs.push_back(addr_array);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id, legacy_addrs);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<RttCapabilities, ndk::ScopedAStatus> WifiRttController::getCapabilitiesInternal() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_rtt_capabilities legacy_caps;
std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRttCapabilities(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {RttCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
}
RttCapabilities aidl_caps;
if (!aidl_struct_util::convertLegacyRttCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
return {RttCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
}
return {aidl_caps, ndk::ScopedAStatus::ok()};
}
ndk::ScopedAStatus WifiRttController::setLciInternal(int32_t cmd_id, const RttLciInformation& lci) {
legacy_hal::wifi_lci_information legacy_lci;
if (!aidl_struct_util::convertAidlRttLciInformationToLegacy(lci, &legacy_lci)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiRttController::setLcrInternal(int32_t cmd_id, const RttLcrInformation& lcr) {
legacy_hal::wifi_lcr_information legacy_lcr;
if (!aidl_struct_util::convertAidlRttLcrInformationToLegacy(lcr, &legacy_lcr)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<RttResponder, ndk::ScopedAStatus> WifiRttController::getResponderInfoInternal() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_rtt_responder legacy_responder;
std::tie(legacy_status, legacy_responder) = legacy_hal_.lock()->getRttResponderInfo(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {RttResponder{}, createWifiStatusFromLegacyError(legacy_status)};
}
RttResponder aidl_responder;
if (!aidl_struct_util::convertLegacyRttResponderToAidl(legacy_responder, &aidl_responder)) {
return {RttResponder{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
}
return {aidl_responder, ndk::ScopedAStatus::ok()};
}
ndk::ScopedAStatus WifiRttController::enableResponderInternal(int32_t cmd_id,
const WifiChannelInfo& channel_hint,
int32_t max_duration_seconds,
const RttResponder& info) {
legacy_hal::wifi_channel_info legacy_channel_info;
if (!aidl_struct_util::convertAidlWifiChannelInfoToLegacy(channel_hint, &legacy_channel_info)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_rtt_responder legacy_responder;
if (!aidl_struct_util::convertAidlRttResponderToLegacy(info, &legacy_responder)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableRttResponder(
ifname_, cmd_id, legacy_channel_info, max_duration_seconds, legacy_responder);
return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiRttController::disableResponderInternal(int32_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

102
wifi/aidl/default/wifi_rtt_controller.h Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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.
*/
#ifndef WIFI_RTT_CONTROLLER_H_
#define WIFI_RTT_CONTROLLER_H_
#include <aidl/android/hardware/wifi/BnWifiRttController.h>
#include <aidl/android/hardware/wifi/IWifiRttControllerEventCallback.h>
#include <aidl/android/hardware/wifi/IWifiStaIface.h>
#include <android-base/macros.h>
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
/**
* AIDL interface object used to control all RTT operations.
*/
class WifiRttController : public BnWifiRttController {
public:
WifiRttController(const std::string& iface_name,
const std::shared_ptr<IWifiStaIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
// Factory method - use instead of default constructor.
static std::shared_ptr<WifiRttController> create(
const std::string& iface_name, const std::shared_ptr<IWifiStaIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::vector<std::shared_ptr<IWifiRttControllerEventCallback>> getEventCallbacks();
std::string getIfaceName();
// AIDL methods exposed.
ndk::ScopedAStatus getBoundIface(std::shared_ptr<IWifiStaIface>* _aidl_return) override;
ndk::ScopedAStatus registerEventCallback(
const std::shared_ptr<IWifiRttControllerEventCallback>& callback) override;
ndk::ScopedAStatus rangeRequest(int32_t in_cmdId,
const std::vector<RttConfig>& in_rttConfigs) override;
ndk::ScopedAStatus rangeCancel(int32_t in_cmdId,
const std::vector<MacAddress>& in_addrs) override;
ndk::ScopedAStatus getCapabilities(RttCapabilities* _aidl_return) override;
ndk::ScopedAStatus setLci(int32_t in_cmdId, const RttLciInformation& in_lci) override;
ndk::ScopedAStatus setLcr(int32_t in_cmdId, const RttLcrInformation& in_lcr) override;
ndk::ScopedAStatus getResponderInfo(RttResponder* _aidl_return) override;
ndk::ScopedAStatus enableResponder(int32_t in_cmdId, const WifiChannelInfo& in_channelHint,
int32_t in_maxDurationInSeconds,
const RttResponder& in_info) override;
ndk::ScopedAStatus disableResponder(int32_t in_cmdId) override;
private:
// Corresponding worker functions for the AIDL methods.
std::pair<std::shared_ptr<IWifiStaIface>, ndk::ScopedAStatus> getBoundIfaceInternal();
ndk::ScopedAStatus registerEventCallbackInternal(
const std::shared_ptr<IWifiRttControllerEventCallback>& callback);
ndk::ScopedAStatus rangeRequestInternal(int32_t cmd_id,
const std::vector<RttConfig>& rtt_configs);
ndk::ScopedAStatus rangeCancelInternal(int32_t cmd_id, const std::vector<MacAddress>& addrs);
std::pair<RttCapabilities, ndk::ScopedAStatus> getCapabilitiesInternal();
ndk::ScopedAStatus setLciInternal(int32_t cmd_id, const RttLciInformation& lci);
ndk::ScopedAStatus setLcrInternal(int32_t cmd_id, const RttLcrInformation& lcr);
std::pair<RttResponder, ndk::ScopedAStatus> getResponderInfoInternal();
ndk::ScopedAStatus enableResponderInternal(int32_t cmd_id, const WifiChannelInfo& channel_hint,
int32_t max_duration_seconds,
const RttResponder& info);
ndk::ScopedAStatus disableResponderInternal(int32_t cmd_id);
void setWeakPtr(std::weak_ptr<WifiRttController> ptr);
std::string ifname_;
std::shared_ptr<IWifiStaIface> bound_iface_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::vector<std::shared_ptr<IWifiRttControllerEventCallback>> event_callbacks_;
std::weak_ptr<WifiRttController> weak_ptr_this_;
bool is_valid_;
DISALLOW_COPY_AND_ASSIGN(WifiRttController);
};
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_RTT_CONTROLLER_H_

558
wifi/aidl/default/wifi_sta_iface.cpp Normal file
View File

@@ -0,0 +1,558 @@
/*
* 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) {
// 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::getCapabilities(
IWifiStaIface::StaIfaceCapabilityMask* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getCapabilitiesInternal, _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::getValidFrequenciesForBand(WifiBand in_band,
std::vector<int32_t>* _aidl_return) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getValidFrequenciesForBandInternal, _aidl_return,
in_band);
}
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);
}
std::pair<std::string, ndk::ScopedAStatus> WifiStaIface::getNameInternal() {
return {ifname_, ndk::ScopedAStatus::ok()};
}
ndk::ScopedAStatus WifiStaIface::registerEventCallbackInternal(
const std::shared_ptr<IWifiStaIfaceEventCallback>& callback) {
if (!event_cb_handler_.addCallback(callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return ndk::ScopedAStatus::ok();
}
std::pair<IWifiStaIface::StaIfaceCapabilityMask, ndk::ScopedAStatus>
WifiStaIface::getCapabilitiesInternal() {
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 {IWifiStaIface::StaIfaceCapabilityMask{},
createWifiStatusFromLegacyError(legacy_status)};
}
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 aidl_caps;
if (!aidl_struct_util::convertLegacyFeaturesToAidlStaCapabilities(
legacy_feature_set, legacy_logger_feature_set, &aidl_caps)) {
return {IWifiStaIface::StaIfaceCapabilityMask{},
createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
}
return {static_cast<IWifiStaIface::StaIfaceCapabilityMask>(aidl_caps),
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()};
}
std::pair<std::vector<int32_t>, ndk::ScopedAStatus>
WifiStaIface::getValidFrequenciesForBandInternal(WifiBand band) {
static_assert(sizeof(WifiChannelWidthInMhz) == sizeof(int32_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_, aidl_struct_util::convertAidlWifiBandToLegacy(band));
return {std::vector<int32_t>(valid_frequencies.begin(), valid_frequencies.end()),
createWifiStatusFromLegacyError(legacy_status)};
}
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;
std::tie(legacy_status, legacy_stats) = legacy_hal_.lock()->getLinkLayerStats(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {StaLinkLayerStats{}, createWifiStatusFromLegacyError(legacy_status)};
}
StaLinkLayerStats aidl_stats;
if (!aidl_struct_util::convertLegacyLinkLayerStatsToAidl(legacy_stats, &aidl_stats)) {
return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
}
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) {
// OEM's need to implement this on their devices if needed.
LOG(WARNING) << "setScanModeInternal(" << enable << ") not supported";
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

154
wifi/aidl/default/wifi_sta_iface.h Normal file
View File

@@ -0,0 +1,154 @@
/*
* 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.
*/
#ifndef WIFI_STA_IFACE_H_
#define WIFI_STA_IFACE_H_
#include <aidl/android/hardware/wifi/BnWifiStaIface.h>
#include <aidl/android/hardware/wifi/IWifiStaIfaceEventCallback.h>
#include <android-base/macros.h>
#include "aidl_callback_util.h"
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
/**
* AIDL interface object used to control a STA Iface instance.
*/
class WifiStaIface : public BnWifiStaIface {
public:
WifiStaIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Factory method - use instead of default constructor.
static std::shared_ptr<WifiStaIface> create(
const std::string& ifname, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::set<std::shared_ptr<IWifiStaIfaceEventCallback>> getEventCallbacks();
std::string getName();
// AIDL methods exposed.
ndk::ScopedAStatus getName(std::string* _aidl_return) override;
ndk::ScopedAStatus registerEventCallback(
const std::shared_ptr<IWifiStaIfaceEventCallback>& in_callback) override;
ndk::ScopedAStatus getCapabilities(
IWifiStaIface::StaIfaceCapabilityMask* _aidl_return) override;
ndk::ScopedAStatus getApfPacketFilterCapabilities(
StaApfPacketFilterCapabilities* _aidl_return) override;
ndk::ScopedAStatus installApfPacketFilter(const std::vector<uint8_t>& in_program) override;
ndk::ScopedAStatus readApfPacketFilterData(std::vector<uint8_t>* _aidl_return) override;
ndk::ScopedAStatus getBackgroundScanCapabilities(
StaBackgroundScanCapabilities* _aidl_return) override;
ndk::ScopedAStatus getValidFrequenciesForBand(WifiBand in_band,
std::vector<int32_t>* _aidl_return) override;
ndk::ScopedAStatus startBackgroundScan(int32_t in_cmdId,
const StaBackgroundScanParameters& in_params) override;
ndk::ScopedAStatus stopBackgroundScan(int32_t in_cmdId) override;
ndk::ScopedAStatus enableLinkLayerStatsCollection(bool in_debug) override;
ndk::ScopedAStatus disableLinkLayerStatsCollection() override;
ndk::ScopedAStatus getLinkLayerStats(StaLinkLayerStats* _aidl_return) override;
ndk::ScopedAStatus startRssiMonitoring(int32_t in_cmdId, int32_t in_maxRssi,
int32_t in_minRssi) override;
ndk::ScopedAStatus stopRssiMonitoring(int32_t in_cmdId) override;
ndk::ScopedAStatus getRoamingCapabilities(StaRoamingCapabilities* _aidl_return) override;
ndk::ScopedAStatus configureRoaming(const StaRoamingConfig& in_config) override;
ndk::ScopedAStatus setRoamingState(StaRoamingState in_state) override;
ndk::ScopedAStatus enableNdOffload(bool in_enable) override;
ndk::ScopedAStatus 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) override;
ndk::ScopedAStatus stopSendingKeepAlivePackets(int32_t in_cmdId) override;
ndk::ScopedAStatus startDebugPacketFateMonitoring() override;
ndk::ScopedAStatus getDebugTxPacketFates(
std::vector<WifiDebugTxPacketFateReport>* _aidl_return) override;
ndk::ScopedAStatus getDebugRxPacketFates(
std::vector<WifiDebugRxPacketFateReport>* _aidl_return) override;
ndk::ScopedAStatus setMacAddress(const std::array<uint8_t, 6>& in_mac) override;
ndk::ScopedAStatus getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) override;
ndk::ScopedAStatus setScanMode(bool in_enable) override;
private:
// Corresponding worker functions for the AIDL methods.
std::pair<std::string, ndk::ScopedAStatus> getNameInternal();
ndk::ScopedAStatus registerEventCallbackInternal(
const std::shared_ptr<IWifiStaIfaceEventCallback>& callback);
std::pair<IWifiStaIface::StaIfaceCapabilityMask, ndk::ScopedAStatus> getCapabilitiesInternal();
std::pair<StaApfPacketFilterCapabilities, ndk::ScopedAStatus>
getApfPacketFilterCapabilitiesInternal();
ndk::ScopedAStatus installApfPacketFilterInternal(const std::vector<uint8_t>& program);
std::pair<std::vector<uint8_t>, ndk::ScopedAStatus> readApfPacketFilterDataInternal();
std::pair<StaBackgroundScanCapabilities, ndk::ScopedAStatus>
getBackgroundScanCapabilitiesInternal();
std::pair<std::vector<int32_t>, ndk::ScopedAStatus> getValidFrequenciesForBandInternal(
WifiBand band);
ndk::ScopedAStatus startBackgroundScanInternal(int32_t cmd_id,
const StaBackgroundScanParameters& params);
ndk::ScopedAStatus stopBackgroundScanInternal(int32_t cmd_id);
ndk::ScopedAStatus enableLinkLayerStatsCollectionInternal(bool debug);
ndk::ScopedAStatus disableLinkLayerStatsCollectionInternal();
std::pair<StaLinkLayerStats, ndk::ScopedAStatus> getLinkLayerStatsInternal();
ndk::ScopedAStatus startRssiMonitoringInternal(int32_t cmd_id, int32_t max_rssi,
int32_t min_rssi);
ndk::ScopedAStatus stopRssiMonitoringInternal(int32_t cmd_id);
std::pair<StaRoamingCapabilities, ndk::ScopedAStatus> getRoamingCapabilitiesInternal();
ndk::ScopedAStatus configureRoamingInternal(const StaRoamingConfig& config);
ndk::ScopedAStatus setRoamingStateInternal(StaRoamingState state);
ndk::ScopedAStatus enableNdOffloadInternal(bool enable);
ndk::ScopedAStatus 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);
ndk::ScopedAStatus stopSendingKeepAlivePacketsInternal(int32_t cmd_id);
ndk::ScopedAStatus startDebugPacketFateMonitoringInternal();
std::pair<std::vector<WifiDebugTxPacketFateReport>, ndk::ScopedAStatus>
getDebugTxPacketFatesInternal();
std::pair<std::vector<WifiDebugRxPacketFateReport>, ndk::ScopedAStatus>
getDebugRxPacketFatesInternal();
ndk::ScopedAStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> getFactoryMacAddressInternal();
ndk::ScopedAStatus setScanModeInternal(bool enable);
void setWeakPtr(std::weak_ptr<WifiStaIface> ptr);
std::string ifname_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
std::weak_ptr<WifiStaIface> weak_ptr_this_;
bool is_valid_;
aidl_callback_util::AidlCallbackHandler<IWifiStaIfaceEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(WifiStaIface);
};
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_STA_IFACE_H_

28
wifi/1.6/default/wifi_status_util.cpp → wifi/aidl/default/wifi_status_util.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -16,11 +16,10 @@
#include "wifi_status_util.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
std::string legacyErrorToString(legacy_hal::wifi_error error) {
switch (error) {
@@ -51,16 +50,21 @@ std::string legacyErrorToString(legacy_hal::wifi_error error) {
}
}
WifiStatus createWifiStatus(WifiStatusCode code, const std::string& description) {
return {code, description};
ndk::ScopedAStatus createWifiStatus(WifiStatusCode code, const std::string& description) {
return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(static_cast<int32_t>(code),
description.c_str());
}
WifiStatus createWifiStatus(WifiStatusCode code) {
return createWifiStatus(code, "");
ndk::ScopedAStatus createWifiStatus(WifiStatusCode code) {
return ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(code));
}
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error, const std::string& desc) {
ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
const std::string& desc) {
switch (error) {
case legacy_hal::WIFI_ERROR_NONE:
return ndk::ScopedAStatus::ok();
case legacy_hal::WIFI_ERROR_UNINITIALIZED:
case legacy_hal::WIFI_ERROR_NOT_AVAILABLE:
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, desc);
@@ -84,9 +88,6 @@ WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error, const s
case legacy_hal::WIFI_ERROR_BUSY:
return createWifiStatus(WifiStatusCode::ERROR_BUSY);
case legacy_hal::WIFI_ERROR_NONE:
return createWifiStatus(WifiStatusCode::SUCCESS, desc);
case legacy_hal::WIFI_ERROR_UNKNOWN:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown");
@@ -95,12 +96,11 @@ WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error, const s
}
}
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error) {
ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error) {
return createWifiStatusFromLegacyError(error, "");
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl

22
wifi/1.6/default/wifi_status_util.h → wifi/aidl/default/wifi_status_util.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 The Android Open Source Project
* 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.
@@ -17,28 +17,26 @@
#ifndef WIFI_STATUS_UTIL_H_
#define WIFI_STATUS_UTIL_H_
#include <android/hardware/wifi/1.4/IWifi.h>
#include <aidl/android/hardware/wifi/IWifi.h>
#include "wifi_legacy_hal.h"
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using ::aidl::android::hardware::wifi::WifiStatusCode;
std::string legacyErrorToString(legacy_hal::wifi_error error);
WifiStatus createWifiStatus(WifiStatusCode code, const std::string& description);
WifiStatus createWifiStatus(WifiStatusCode code);
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
const std::string& description);
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error);
ndk::ScopedAStatus createWifiStatus(WifiStatusCode code, const std::string& description);
ndk::ScopedAStatus createWifiStatus(WifiStatusCode code);
ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
const std::string& description);
ndk::ScopedAStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error);
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
} // namespace aidl
#endif // WIFI_STATUS_UTIL_H_

169
wifi/aidl/vts/functional/Android.bp Normal file
View File

@@ -0,0 +1,169 @@
//
// 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.
//
package {
// See: http://go/android-license-faq
// A large-scale-change added 'default_applicable_licenses' to import
// all of the 'license_kinds' from "hardware_interfaces_license"
// to get the below license kinds:
// SPDX-license-identifier-Apache-2.0
default_applicable_licenses: ["hardware_interfaces_license"],
}
cc_test {
name: "VtsHalWifiChipTargetTest",
defaults: [
"VtsHalTargetTestDefaults",
"use_libaidlvintf_gtest_helper_static",
],
srcs: [
"wifi_chip_aidl_test.cpp",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
"libvndksupport",
],
static_libs: [
"VtsHalWifiTargetTestUtil",
"android.hardware.wifi-V1-ndk",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}
cc_test {
name: "VtsHalWifiStaIfaceTargetTest",
defaults: [
"VtsHalTargetTestDefaults",
"use_libaidlvintf_gtest_helper_static",
],
srcs: [
"wifi_sta_iface_aidl_test.cpp",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
"libvndksupport",
],
static_libs: [
"VtsHalWifiTargetTestUtil",
"android.hardware.wifi-V1-ndk",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}
cc_test {
name: "VtsHalWifiApIfaceTargetTest",
defaults: [
"VtsHalTargetTestDefaults",
"use_libaidlvintf_gtest_helper_static",
],
srcs: [
"wifi_ap_iface_aidl_test.cpp",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
"libvndksupport",
],
static_libs: [
"VtsHalWifiTargetTestUtil",
"android.hardware.wifi-V1-ndk",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}
cc_test {
name: "VtsHalWifiNanIfaceTargetTest",
defaults: [
"VtsHalTargetTestDefaults",
"use_libaidlvintf_gtest_helper_static",
],
srcs: [
"wifi_nan_iface_aidl_test.cpp",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
"libvndksupport",
],
static_libs: [
"VtsHalWifiTargetTestUtil",
"android.hardware.wifi-V1-ndk",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}
cc_test {
name: "VtsHalWifiRttControllerTargetTest",
defaults: [
"VtsHalTargetTestDefaults",
"use_libaidlvintf_gtest_helper_static",
],
srcs: [
"wifi_rtt_controller_aidl_test.cpp",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
"libvndksupport",
],
static_libs: [
"VtsHalWifiTargetTestUtil",
"android.hardware.wifi-V1-ndk",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}
cc_library_static {
name: "VtsHalWifiTargetTestUtil",
defaults: ["VtsHalTargetTestDefaults"],
srcs: [
"wifi_aidl_test_utils.cpp",
],
export_include_dirs: [
".",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
"libnativehelper",
],
static_libs: [
"android.hardware.wifi-V1-ndk",
"libwifi-system-iface",
],
}

216
wifi/aidl/vts/functional/wifi_aidl_test_utils.cpp Normal file
View File

@@ -0,0 +1,216 @@
/*
* 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_aidl_test_utils.h"
using ::android::wifi_system::InterfaceTool;
namespace {
bool findAnyModeSupportingConcurrencyType(IfaceConcurrencyType desired_type,
const std::vector<IWifiChip::ChipMode>& modes,
int* mode_id) {
for (const auto& mode : modes) {
for (const auto& combination : mode.availableCombinations) {
for (const auto& iface_limit : combination.limits) {
const auto& iface_types = iface_limit.types;
if (std::find(iface_types.begin(), iface_types.end(), desired_type) !=
iface_types.end()) {
*mode_id = mode.id;
return true;
}
}
}
}
return false;
}
bool configureChipToSupportConcurrencyTypeInternal(const std::shared_ptr<IWifiChip>& wifi_chip,
IfaceConcurrencyType type,
int* configured_mode_id) {
if (!configured_mode_id) {
return false;
}
std::vector<IWifiChip::ChipMode> chip_modes;
auto status = wifi_chip->getAvailableModes(&chip_modes);
if (!status.isOk()) {
return false;
}
if (!findAnyModeSupportingConcurrencyType(type, chip_modes, configured_mode_id)) {
return false;
}
if (!wifi_chip->configureChip(*configured_mode_id).isOk()) {
return false;
}
return true;
}
bool configureChipToSupportConcurrencyTypeInternal(const std::shared_ptr<IWifiChip>& wifi_chip,
IfaceConcurrencyType type) {
int mode_id;
return configureChipToSupportConcurrencyTypeInternal(wifi_chip, type, &mode_id);
}
} // namespace
bool checkStatusCode(ndk::ScopedAStatus* status, WifiStatusCode expected_code) {
if (status == nullptr) {
return false;
}
return status->getServiceSpecificError() == static_cast<int32_t>(expected_code);
}
std::shared_ptr<IWifi> getWifi(const char* instance_name) {
return IWifi::fromBinder(ndk::SpAIBinder(AServiceManager_waitForService(instance_name)));
}
std::shared_ptr<IWifiChip> getWifiChip(const char* instance_name) {
std::shared_ptr<IWifi> wifi = getWifi(instance_name);
if (!wifi.get()) {
return nullptr;
}
const int retry_interval_ms = 2;
const int max_retries = 5;
int retry_count = 0;
auto status = wifi->start();
while (retry_count < max_retries && !status.isOk()) {
retry_count++;
usleep(retry_interval_ms * 1000);
status = wifi->start();
}
if (!status.isOk()) {
return nullptr;
}
std::vector<int> chip_ids = {};
status = wifi->getChipIds(&chip_ids);
if (!status.isOk() || chip_ids.size() == 0) {
return nullptr;
}
std::shared_ptr<IWifiChip> chip;
status = wifi->getChip(chip_ids[0], &chip);
if (!status.isOk()) {
return nullptr;
}
return chip;
}
void setupStaIface(const std::shared_ptr<IWifiStaIface>& iface) {
std::string iface_name;
auto status = iface->getName(&iface_name);
if (status.isOk()) {
InterfaceTool iface_tool;
iface_tool.SetUpState(iface_name.c_str(), true);
}
}
void setupNanIface(const std::shared_ptr<IWifiNanIface>& iface) {
std::string iface_name;
auto status = iface->getName(&iface_name);
if (status.isOk()) {
InterfaceTool iface_tool;
iface_tool.SetUpState(iface_name.c_str(), true);
}
}
std::shared_ptr<IWifiStaIface> getWifiStaIface(const char* instance_name) {
std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
if (!wifi_chip.get()) {
return nullptr;
}
if (!configureChipToSupportConcurrencyTypeInternal(wifi_chip, IfaceConcurrencyType::STA)) {
return nullptr;
}
std::shared_ptr<IWifiStaIface> iface;
auto status = wifi_chip->createStaIface(&iface);
if (!status.isOk()) {
return nullptr;
}
setupStaIface(iface);
return iface;
}
std::shared_ptr<IWifiNanIface> getWifiNanIface(const char* instance_name) {
std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
if (!wifi_chip.get()) {
return nullptr;
}
if (!configureChipToSupportConcurrencyTypeInternal(wifi_chip,
IfaceConcurrencyType::NAN_IFACE)) {
return nullptr;
}
std::shared_ptr<IWifiNanIface> iface;
auto status = wifi_chip->createNanIface(&iface);
if (!status.isOk()) {
return nullptr;
}
setupNanIface(iface);
return iface;
}
std::shared_ptr<IWifiApIface> getWifiApIface(const char* instance_name) {
std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
if (!wifi_chip.get()) {
return nullptr;
}
if (!configureChipToSupportConcurrencyTypeInternal(wifi_chip, IfaceConcurrencyType::AP)) {
return nullptr;
}
std::shared_ptr<IWifiApIface> iface;
auto status = wifi_chip->createApIface(&iface);
if (!status.isOk()) {
return nullptr;
}
return iface;
}
std::shared_ptr<IWifiApIface> getBridgedWifiApIface(std::shared_ptr<IWifiChip> wifi_chip) {
if (!wifi_chip.get()) {
return nullptr;
}
int mode_id;
std::shared_ptr<IWifiApIface> iface;
configureChipToSupportConcurrencyTypeInternal(wifi_chip, IfaceConcurrencyType::AP, &mode_id);
auto status = wifi_chip->createBridgedApIface(&iface);
if (!status.isOk()) {
return nullptr;
}
return iface;
}
std::shared_ptr<IWifiApIface> getBridgedWifiApIface(const char* instance_name) {
std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(instance_name);
return getBridgedWifiApIface(wifi_chip);
}
bool configureChipToSupportConcurrencyType(const std::shared_ptr<IWifiChip>& wifi_chip,
IfaceConcurrencyType type, int* configured_mode_id) {
return configureChipToSupportConcurrencyTypeInternal(wifi_chip, type, configured_mode_id);
}
void stopWifiService(const char* instance_name) {
std::shared_ptr<IWifi> wifi = getWifi(instance_name);
if (wifi != nullptr) {
wifi->stop();
}
}
int32_t getChipCapabilities(const std::shared_ptr<IWifiChip>& wifi_chip) {
IWifiChip::ChipCapabilityMask caps = {};
if (wifi_chip->getCapabilities(&caps).isOk()) {
return static_cast<int32_t>(caps);
}
return 0;
}

48
wifi/aidl/vts/functional/wifi_aidl_test_utils.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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.
*/
#pragma once
#include <VtsCoreUtil.h>
#include <aidl/android/hardware/wifi/IWifi.h>
#include <aidl/android/hardware/wifi/IWifiChip.h>
#include <android/binder_manager.h>
#include <wifi_system/interface_tool.h>
using aidl::android::hardware::wifi::IfaceConcurrencyType;
using aidl::android::hardware::wifi::IWifi;
using aidl::android::hardware::wifi::IWifiApIface;
using aidl::android::hardware::wifi::IWifiChip;
using aidl::android::hardware::wifi::IWifiNanIface;
using aidl::android::hardware::wifi::IWifiStaIface;
using aidl::android::hardware::wifi::WifiStatusCode;
// Helper functions to obtain references to the various AIDL interface objects.
std::shared_ptr<IWifi> getWifi(const char* instance_name);
std::shared_ptr<IWifiChip> getWifiChip(const char* instance_name);
std::shared_ptr<IWifiStaIface> getWifiStaIface(const char* instance_name);
std::shared_ptr<IWifiNanIface> getWifiNanIface(const char* instance_name);
std::shared_ptr<IWifiApIface> getWifiApIface(const char* instance_name);
std::shared_ptr<IWifiApIface> getBridgedWifiApIface(const char* instance_name);
std::shared_ptr<IWifiApIface> getBridgedWifiApIface(std::shared_ptr<IWifiChip> wifi_chip);
// Configure the chip in a mode to support the creation of the provided iface type.
bool configureChipToSupportConcurrencyType(const std::shared_ptr<IWifiChip>& wifi_chip,
IfaceConcurrencyType type, int* configured_mode_id);
// Used to trigger IWifi.stop() at the end of every test.
void stopWifiService(const char* instance_name);
int32_t getChipCapabilities(const std::shared_ptr<IWifiChip>& wifi_chip);
bool checkStatusCode(ndk::ScopedAStatus* status, WifiStatusCode expected_code);

154
wifi/aidl/vts/functional/wifi_ap_iface_aidl_test.cpp Normal file
View File

@@ -0,0 +1,154 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Staache 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 <vector>
#include <VtsCoreUtil.h>
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/wifi/BnWifi.h>
#include <android/binder_manager.h>
#include <android/binder_status.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include "wifi_aidl_test_utils.h"
using aidl::android::hardware::wifi::IWifiApIface;
using aidl::android::hardware::wifi::WifiBand;
class WifiApIfaceAidlTest : public testing::TestWithParam<std::string> {
public:
void SetUp() override {
isBridgedSupport_ = testing::checkSubstringInCommandOutput(
"/system/bin/cmd wifi get-softap-supported-features",
"wifi_softap_bridged_ap_supported");
stopWifiService(getInstanceName());
}
void TearDown() override { stopWifiService(getInstanceName()); }
protected:
bool isBridgedSupport_ = false;
const char* getInstanceName() { return GetParam().c_str(); }
};
/*
* SetMacAddress
*/
TEST_P(WifiApIfaceAidlTest, SetMacAddress) {
std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
std::array<uint8_t, 6> mac = {0x12, 0x22, 0x33, 0x52, 0x10, 0x44};
EXPECT_TRUE(wifi_ap_iface->setMacAddress(mac).isOk());
}
/*
* SetCountryCode
*/
TEST_P(WifiApIfaceAidlTest, SetCountryCode) {
std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
const std::array<uint8_t, 2> country_code = {0x55, 0x53};
EXPECT_TRUE(wifi_ap_iface->setCountryCode(country_code).isOk());
}
/*
* GetValidFrequenciesForBand
* Ensures that we can retrieve valid frequencies for the 2.4 GHz band.
*/
TEST_P(WifiApIfaceAidlTest, GetValidFrequenciesForBand) {
std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
std::vector<int32_t> freqs;
EXPECT_TRUE(wifi_ap_iface->getValidFrequenciesForBand(WifiBand::BAND_24GHZ, &freqs).isOk());
EXPECT_NE(freqs.size(), 0);
}
/*
* GetFactoryMacAddress
*/
TEST_P(WifiApIfaceAidlTest, GetFactoryMacAddress) {
std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
std::array<uint8_t, 6> mac;
EXPECT_TRUE(wifi_ap_iface->getFactoryMacAddress(&mac).isOk());
std::array<uint8_t, 6> all_zero_mac = {0, 0, 0, 0, 0, 0};
EXPECT_NE(mac, all_zero_mac);
}
/**
* GetBridgedInstances - non-bridged mode
*/
TEST_P(WifiApIfaceAidlTest, GetBridgedInstances) {
std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
std::vector<std::string> instances;
EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
EXPECT_EQ(instances.size(), 0);
}
/**
* GetBridgedInstances - bridged AP mode.
*/
TEST_P(WifiApIfaceAidlTest, GetBridgedInstances_Bridged) {
if (!isBridgedSupport_) {
GTEST_SKIP() << "Missing Bridged AP support";
}
std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
std::vector<std::string> instances;
EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
EXPECT_EQ(instances.size(), 2);
}
/**
* ResetToFactoryMacAddress - non-bridged mode
*/
TEST_P(WifiApIfaceAidlTest, ResetToFactoryMacAddress) {
std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
EXPECT_TRUE(wifi_ap_iface->resetToFactoryMacAddress().isOk());
}
/**
* ResetToFactoryMacAddress - bridged AP mode
*/
TEST_P(WifiApIfaceAidlTest, ResetToFactoryMacAddress_Bridged) {
if (!isBridgedSupport_) {
GTEST_SKIP() << "Missing Bridged AP support";
}
std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(getInstanceName());
ASSERT_NE(nullptr, wifi_ap_iface.get());
EXPECT_TRUE(wifi_ap_iface->resetToFactoryMacAddress().isOk());
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiApIfaceAidlTest);
INSTANTIATE_TEST_SUITE_P(WifiTest, WifiApIfaceAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
android::PrintInstanceNameToString);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
android::ProcessState::self()->startThreadPool();
return RUN_ALL_TESTS();
}

889
wifi/aidl/vts/functional/wifi_chip_aidl_test.cpp Normal file
View File

@@ -0,0 +1,889 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Staache 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 <numeric>
#include <vector>
#include <VtsCoreUtil.h>
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/wifi/BnWifi.h>
#include <aidl/android/hardware/wifi/BnWifiChipEventCallback.h>
#include <android/binder_manager.h>
#include <android/binder_status.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include "wifi_aidl_test_utils.h"
using aidl::android::hardware::wifi::BnWifiChipEventCallback;
using aidl::android::hardware::wifi::IfaceType;
using aidl::android::hardware::wifi::IWifiApIface;
using aidl::android::hardware::wifi::IWifiChip;
using aidl::android::hardware::wifi::IWifiNanIface;
using aidl::android::hardware::wifi::IWifiP2pIface;
using aidl::android::hardware::wifi::IWifiRttController;
using aidl::android::hardware::wifi::WifiBand;
using aidl::android::hardware::wifi::WifiDebugHostWakeReasonStats;
using aidl::android::hardware::wifi::WifiDebugRingBufferStatus;
using aidl::android::hardware::wifi::WifiDebugRingBufferVerboseLevel;
using aidl::android::hardware::wifi::WifiIfaceMode;
using aidl::android::hardware::wifi::WifiRadioCombinationMatrix;
using aidl::android::hardware::wifi::WifiStatusCode;
using aidl::android::hardware::wifi::WifiUsableChannel;
class WifiChipAidlTest : public testing::TestWithParam<std::string> {
public:
void SetUp() override {
stopWifiService(getInstanceName());
wifi_chip_ = getWifiChip(getInstanceName());
ASSERT_NE(nullptr, wifi_chip_.get());
}
void TearDown() override { stopWifiService(getInstanceName()); }
protected:
int configureChipForConcurrencyType(IfaceConcurrencyType type) {
int mode_id;
EXPECT_TRUE(configureChipToSupportConcurrencyType(wifi_chip_, type, &mode_id));
return mode_id;
}
std::shared_ptr<IWifiStaIface> configureChipForStaAndGetIface() {
std::shared_ptr<IWifiStaIface> iface;
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
EXPECT_NE(nullptr, iface.get());
return iface;
}
std::shared_ptr<IWifiP2pIface> configureChipForP2pAndGetIface() {
std::shared_ptr<IWifiP2pIface> iface;
configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
EXPECT_NE(nullptr, iface.get());
return iface;
}
std::shared_ptr<IWifiApIface> configureChipForApAndGetIface() {
std::shared_ptr<IWifiApIface> iface;
configureChipForConcurrencyType(IfaceConcurrencyType::AP);
EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
EXPECT_NE(nullptr, iface.get());
return iface;
}
std::shared_ptr<IWifiNanIface> configureChipForNanAndGetIface() {
std::shared_ptr<IWifiNanIface> iface;
configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
EXPECT_NE(nullptr, iface.get());
return iface;
}
std::string getStaIfaceName(const std::shared_ptr<IWifiStaIface>& iface) {
std::string iface_name;
EXPECT_TRUE(iface->getName(&iface_name).isOk());
return iface_name;
}
std::string getP2pIfaceName(const std::shared_ptr<IWifiP2pIface>& iface) {
std::string iface_name;
EXPECT_TRUE(iface->getName(&iface_name).isOk());
return iface_name;
}
std::string getApIfaceName(const std::shared_ptr<IWifiApIface>& iface) {
std::string iface_name;
EXPECT_TRUE(iface->getName(&iface_name).isOk());
return iface_name;
}
std::string getNanIfaceName(const std::shared_ptr<IWifiNanIface>& iface) {
std::string iface_name;
EXPECT_TRUE(iface->getName(&iface_name).isOk());
return iface_name;
}
std::vector<std::shared_ptr<IWifiStaIface>> create2StaIfacesIfPossible() {
std::shared_ptr<IWifiStaIface> iface1 = configureChipForStaAndGetIface();
// Try create a create second iface.
std::shared_ptr<IWifiStaIface> iface2;
bool add_second_success = wifi_chip_->createStaIface(&iface2).isOk();
if (!add_second_success) {
return {iface1};
}
EXPECT_NE(nullptr, iface2.get());
return {iface1, iface2};
}
bool hasAnyRingBufferCapabilities(int32_t caps) {
return caps &
(static_cast<int32_t>(
IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_CONNECT_EVENT) |
static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_POWER_EVENT) |
static_cast<int32_t>(
IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_WAKELOCK_EVENT) |
static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_VENDOR_DATA));
}
const char* getInstanceName() { return GetParam().c_str(); }
std::shared_ptr<IWifiChip> wifi_chip_;
};
class WifiChipEventCallback : public BnWifiChipEventCallback {
public:
WifiChipEventCallback() = default;
::ndk::ScopedAStatus onChipReconfigureFailure(WifiStatusCode /* status */) override {
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus onChipReconfigured(int /* modeId */) override {
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus onDebugErrorAlert(int /* errorCode */,
const std::vector<uint8_t>& /* debugData */) override {
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus onDebugRingBufferDataAvailable(
const WifiDebugRingBufferStatus& /* status */,
const std::vector<uint8_t>& /* data */) override {
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus onIfaceAdded(IfaceType /* type */,
const std::string& /* name */) override {
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus onIfaceRemoved(IfaceType /* type */,
const std::string& /* name */) override {
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus onRadioModeChange(
const std::vector<RadioModeInfo>& /* radioModeInfos */) override {
return ndk::ScopedAStatus::ok();
}
};
/*
* RegisterEventCallback
*
* Note: it is not feasible to test the invocation of the callback function,
* since events are triggered internally in the HAL implementation and cannot be
* triggered from the test case.
*/
TEST_P(WifiChipAidlTest, RegisterEventCallback) {
std::shared_ptr<WifiChipEventCallback> callback =
ndk::SharedRefBase::make<WifiChipEventCallback>();
ASSERT_NE(nullptr, callback.get());
EXPECT_TRUE(wifi_chip_->registerEventCallback(callback).isOk());
}
/*
* GetCapabilities
*/
TEST_P(WifiChipAidlTest, GetCapabilities) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
EXPECT_NE(static_cast<int32_t>(caps), 0);
}
/*
* GetId
*/
TEST_P(WifiChipAidlTest, GetId) {
int id;
EXPECT_TRUE(wifi_chip_->getId(&id).isOk());
}
/*
* GetAvailableModes
*/
TEST_P(WifiChipAidlTest, GetAvailableModes) {
std::vector<IWifiChip::ChipMode> modes;
EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
EXPECT_NE(modes.size(), 0);
}
/*
* GetMode
*/
TEST_P(WifiChipAidlTest, GetMode) {
int expected_mode = configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int retrieved_mode;
EXPECT_TRUE(wifi_chip_->getMode(&retrieved_mode).isOk());
EXPECT_EQ(retrieved_mode, expected_mode);
}
/*
* GetUsableChannels
*/
TEST_P(WifiChipAidlTest, GetUsableChannels) {
WifiBand band = WifiBand::BAND_24GHZ_5GHZ_6GHZ;
uint32_t ifaceModeMask = static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_CLIENT) |
static_cast<uint32_t>(WifiIfaceMode::IFACE_MODE_P2P_GO);
uint32_t filterMask =
static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE) |
static_cast<uint32_t>(IWifiChip::UsableChannelFilter::CONCURRENCY);
std::vector<WifiUsableChannel> channels;
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
auto status = wifi_chip_->getUsableChannels(
band, static_cast<WifiIfaceMode>(ifaceModeMask),
static_cast<IWifiChip::UsableChannelFilter>(filterMask), &channels);
if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
GTEST_SKIP() << "getUsableChannels() is not supported by vendor.";
}
EXPECT_TRUE(status.isOk());
}
/*
* GetSupportedRadioCombinationsMatrix
*/
TEST_P(WifiChipAidlTest, GetSupportedRadioCombinationsMatrix) {
WifiRadioCombinationMatrix combination_matrix = {};
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
auto status = wifi_chip_->getSupportedRadioCombinationsMatrix(&combination_matrix);
if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
GTEST_SKIP() << "Skipping this test since getSupportedRadioCombinationsMatrix() "
"is not supported by vendor.";
}
EXPECT_TRUE(status.isOk());
}
/*
* SetCountryCode
*/
TEST_P(WifiChipAidlTest, SetCountryCode) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
std::array<uint8_t, 2> country_code = {0x55, 0x53};
EXPECT_TRUE(wifi_chip_->setCountryCode(country_code).isOk());
}
/*
* SetLatencyMode_normal
* Tests the setLatencyMode() API with Latency mode NORMAL.
*/
TEST_P(WifiChipAidlTest, SetLatencyMode_normal) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::NORMAL);
if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_LATENCY_MODE)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* SetLatencyMode_low
* Tests the setLatencyMode() API with Latency mode LOW.
*/
TEST_P(WifiChipAidlTest, SetLatencyMode_low) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
auto status = wifi_chip_->setLatencyMode(IWifiChip::LatencyMode::LOW);
if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_LATENCY_MODE)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* SetMultiStaPrimaryConnection
*
* Only runs if the device supports 2 STA ifaces.
*/
TEST_P(WifiChipAidlTest, SetMultiStaPrimaryConnection) {
auto ifaces = create2StaIfacesIfPossible();
if (ifaces.size() < 2) {
GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
}
auto status = wifi_chip_->setMultiStaPrimaryConnection(getStaIfaceName(ifaces[0]));
if (!status.isOk()) {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* SetMultiStaUseCase
*
* Only runs if the device supports 2 STA ifaces.
*/
TEST_P(WifiChipAidlTest, setMultiStaUseCase) {
auto ifaces = create2StaIfacesIfPossible();
if (ifaces.size() < 2) {
GTEST_SKIP() << "Device does not support more than 1 STA concurrently";
}
auto status = wifi_chip_->setMultiStaUseCase(
IWifiChip::MultiStaUseCase::DUAL_STA_TRANSIENT_PREFER_PRIMARY);
if (!status.isOk()) {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* SetCoexUnsafeChannels
*/
TEST_P(WifiChipAidlTest, SetCoexUnsafeChannels) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
// Test with an empty vector of CoexUnsafeChannels.
std::vector<IWifiChip::CoexUnsafeChannel> vec;
IWifiChip::CoexRestriction restrictions = static_cast<IWifiChip::CoexRestriction>(0);
auto status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
if (!status.isOk()) {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
// Test with a non-empty vector of CoexUnsafeChannels.
IWifiChip::CoexUnsafeChannel unsafeChannel24Ghz;
unsafeChannel24Ghz.band = WifiBand::BAND_24GHZ;
unsafeChannel24Ghz.channel = 6;
vec.push_back(unsafeChannel24Ghz);
IWifiChip::CoexUnsafeChannel unsafeChannel5Ghz;
unsafeChannel5Ghz.band = WifiBand::BAND_5GHZ;
unsafeChannel5Ghz.channel = 36;
vec.push_back(unsafeChannel5Ghz);
restrictions = static_cast<IWifiChip::CoexRestriction>(
static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_AWARE) |
static_cast<int32_t>(IWifiChip::CoexRestriction::SOFTAP) |
static_cast<int32_t>(IWifiChip::CoexRestriction::WIFI_DIRECT));
status = wifi_chip_->setCoexUnsafeChannels(vec, restrictions);
if (!status.isOk()) {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* SelectTxPowerScenario - Body
*/
TEST_P(WifiChipAidlTest, SelectTxPowerScenario_body) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
int32_t expected_caps =
static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT) |
static_cast<int32_t>(IWifiChip::ChipCapabilityMask::USE_BODY_HEAD_SAR);
auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::ON_BODY_CELL_OFF);
if (caps & expected_caps) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* SelectTxPowerScenario - Voice Call
*/
TEST_P(WifiChipAidlTest, SelectTxPowerScenario_voiceCall) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
auto status = wifi_chip_->selectTxPowerScenario(IWifiChip::TxPowerScenario::VOICE_CALL);
if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* ResetTxPowerScenario
*/
TEST_P(WifiChipAidlTest, ResetTxPowerScenario) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
auto status = wifi_chip_->resetTxPowerScenario();
if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::SET_TX_POWER_LIMIT)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* ConfigureChip
*/
TEST_P(WifiChipAidlTest, ConfigureChip) {
std::vector<IWifiChip::ChipMode> modes;
EXPECT_TRUE(wifi_chip_->getAvailableModes(&modes).isOk());
EXPECT_NE(modes.size(), 0);
for (const auto& mode : modes) {
// configureChip() requires a fresh IWifiChip object.
wifi_chip_ = getWifiChip(getInstanceName());
ASSERT_NE(nullptr, wifi_chip_.get());
EXPECT_TRUE(wifi_chip_->configureChip(mode.id).isOk());
stopWifiService(getInstanceName());
// Sleep for 5 milliseconds between each wifi state toggle.
usleep(5000);
}
}
/*
* RequestChipDebugInfo
*/
TEST_P(WifiChipAidlTest, RequestChipDebugInfo) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
IWifiChip::ChipDebugInfo debug_info = {};
EXPECT_TRUE(wifi_chip_->requestChipDebugInfo(&debug_info).isOk());
EXPECT_NE(debug_info.driverDescription.size(), 0);
EXPECT_NE(debug_info.firmwareDescription.size(), 0);
}
/*
* RequestFirmwareDebugDump
*/
TEST_P(WifiChipAidlTest, RequestFirmwareDebugDump) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
std::vector<uint8_t> debug_dump;
auto status = wifi_chip_->requestFirmwareDebugDump(&debug_dump);
if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* RequestDriverDebugDump
*/
TEST_P(WifiChipAidlTest, RequestDriverDebugDump) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
std::vector<uint8_t> debug_dump;
auto status = wifi_chip_->requestDriverDebugDump(&debug_dump);
if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* GetDebugRingBuffersStatus
*/
TEST_P(WifiChipAidlTest, GetDebugRingBuffersStatus) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
if (hasAnyRingBufferCapabilities(caps)) {
EXPECT_TRUE(status.isOk());
ASSERT_NE(ring_buffer_status.size(), 0);
for (const auto& ring_buffer : ring_buffer_status) {
EXPECT_NE(ring_buffer.ringName.size(), 0);
}
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* GetDebugHostWakeReasonStats
*/
TEST_P(WifiChipAidlTest, GetDebugHostWakeReasonStats) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
WifiDebugHostWakeReasonStats wake_reason_stats = {};
auto status = wifi_chip_->getDebugHostWakeReasonStats(&wake_reason_stats);
if (caps & static_cast<int32_t>(IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* StartLoggingToDebugRingBuffer
*/
TEST_P(WifiChipAidlTest, StartLoggingToDebugRingBuffer) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
std::string ring_name;
std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
if (hasAnyRingBufferCapabilities(caps)) {
EXPECT_TRUE(status.isOk());
ASSERT_NE(ring_buffer_status.size(), 0);
ring_name = ring_buffer_status[0].ringName;
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
status = wifi_chip_->startLoggingToDebugRingBuffer(
ring_name, WifiDebugRingBufferVerboseLevel::VERBOSE, 5, 1024);
if (hasAnyRingBufferCapabilities(caps)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* ForceDumpToDebugRingBuffer
*/
TEST_P(WifiChipAidlTest, ForceDumpToDebugRingBuffer) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
int32_t caps = getChipCapabilities(wifi_chip_);
std::string ring_name;
std::vector<WifiDebugRingBufferStatus> ring_buffer_status;
auto status = wifi_chip_->getDebugRingBuffersStatus(&ring_buffer_status);
if (hasAnyRingBufferCapabilities(caps)) {
EXPECT_TRUE(status.isOk());
ASSERT_NE(ring_buffer_status.size(), 0);
ring_name = ring_buffer_status[0].ringName;
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
status = wifi_chip_->forceDumpToDebugRingBuffer(ring_name);
if (hasAnyRingBufferCapabilities(caps)) {
EXPECT_TRUE(status.isOk());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/*
* CreateStaIface
* Configures the chip in STA mode and creates an iface.
*/
TEST_P(WifiChipAidlTest, CreateStaIface) {
configureChipForStaAndGetIface();
}
/*
* CreateApIface
*/
TEST_P(WifiChipAidlTest, CreateApIface) {
configureChipForApAndGetIface();
}
/*
* CreateNanIface
*/
TEST_P(WifiChipAidlTest, CreateNanIface) {
configureChipForNanAndGetIface();
}
/*
* CreateP2pIface
*/
TEST_P(WifiChipAidlTest, CreateP2pIface) {
configureChipForNanAndGetIface();
}
/*
* GetStaIfaceNames
* Configures the chip in STA mode and ensures that the iface name list is
* empty before creating the iface. Then create the iface and ensure that
* iface name is returned in the iface name list.
*/
TEST_P(WifiChipAidlTest, GetStaIfaceNames) {
configureChipForConcurrencyType(IfaceConcurrencyType::STA);
std::vector<std::string> iface_names;
EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
std::shared_ptr<IWifiStaIface> iface;
EXPECT_TRUE(wifi_chip_->createStaIface(&iface).isOk());
ASSERT_NE(nullptr, iface.get());
std::string iface_name = getStaIfaceName(iface);
EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 1);
EXPECT_EQ(iface_name, iface_names[0]);
EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
EXPECT_TRUE(wifi_chip_->getStaIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
}
/*
* GetP2pIfaceNames
*/
TEST_P(WifiChipAidlTest, GetP2pIfaceNames) {
configureChipForConcurrencyType(IfaceConcurrencyType::P2P);
std::vector<std::string> iface_names;
EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
std::shared_ptr<IWifiP2pIface> iface;
EXPECT_TRUE(wifi_chip_->createP2pIface(&iface).isOk());
ASSERT_NE(nullptr, iface.get());
std::string iface_name = getP2pIfaceName(iface);
EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 1);
EXPECT_EQ(iface_name, iface_names[0]);
EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
EXPECT_TRUE(wifi_chip_->getP2pIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
}
/*
* GetApIfaceNames
*/
TEST_P(WifiChipAidlTest, GetApIfaceNames) {
configureChipForConcurrencyType(IfaceConcurrencyType::AP);
std::vector<std::string> iface_names;
EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
std::shared_ptr<IWifiApIface> iface;
EXPECT_TRUE(wifi_chip_->createApIface(&iface).isOk());
ASSERT_NE(nullptr, iface.get());
std::string iface_name = getApIfaceName(iface);
EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 1);
EXPECT_EQ(iface_name, iface_names[0]);
EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
EXPECT_TRUE(wifi_chip_->getApIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
}
/*
* GetNanIfaceNames
*/
TEST_P(WifiChipAidlTest, GetNanIfaceNames) {
configureChipForConcurrencyType(IfaceConcurrencyType::NAN_IFACE);
std::vector<std::string> iface_names;
EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
std::shared_ptr<IWifiNanIface> iface;
EXPECT_TRUE(wifi_chip_->createNanIface(&iface).isOk());
ASSERT_NE(nullptr, iface.get());
std::string iface_name = getNanIfaceName(iface);
EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 1);
EXPECT_EQ(iface_name, iface_names[0]);
EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
EXPECT_TRUE(wifi_chip_->getNanIfaceNames(&iface_names).isOk());
EXPECT_EQ(iface_names.size(), 0);
}
/*
* GetStaIface
* Configures the chip in STA mode and creates an iface. Then retrieves
* the iface object using its name and ensures that any other name
* doesn't retrieve a valid iface object.
*/
TEST_P(WifiChipAidlTest, GetStaIface) {
std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
std::string iface_name = getStaIfaceName(iface);
std::shared_ptr<IWifiStaIface> retrieved_iface;
EXPECT_TRUE(wifi_chip_->getStaIface(iface_name, &retrieved_iface).isOk());
EXPECT_NE(nullptr, retrieved_iface.get());
std::string invalid_name = iface_name + "0";
std::shared_ptr<IWifiStaIface> invalid_iface;
auto status = wifi_chip_->getStaIface(invalid_name, &invalid_iface);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_EQ(nullptr, invalid_iface.get());
}
/*
* GetP2pIface
*/
TEST_P(WifiChipAidlTest, GetP2pIface) {
std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
std::string iface_name = getP2pIfaceName(iface);
std::shared_ptr<IWifiP2pIface> retrieved_iface;
EXPECT_TRUE(wifi_chip_->getP2pIface(iface_name, &retrieved_iface).isOk());
EXPECT_NE(nullptr, retrieved_iface.get());
std::string invalid_name = iface_name + "0";
std::shared_ptr<IWifiP2pIface> invalid_iface;
auto status = wifi_chip_->getP2pIface(invalid_name, &invalid_iface);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_EQ(nullptr, invalid_iface.get());
}
/*
* GetApIface
*/
TEST_P(WifiChipAidlTest, GetApIface) {
std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
std::string iface_name = getApIfaceName(iface);
std::shared_ptr<IWifiApIface> retrieved_iface;
EXPECT_TRUE(wifi_chip_->getApIface(iface_name, &retrieved_iface).isOk());
EXPECT_NE(nullptr, retrieved_iface.get());
std::string invalid_name = iface_name + "0";
std::shared_ptr<IWifiApIface> invalid_iface;
auto status = wifi_chip_->getApIface(invalid_name, &invalid_iface);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_EQ(nullptr, invalid_iface.get());
}
/*
* GetNanIface
*/
TEST_P(WifiChipAidlTest, GetNanIface) {
std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
std::string iface_name = getNanIfaceName(iface);
std::shared_ptr<IWifiNanIface> retrieved_iface;
EXPECT_TRUE(wifi_chip_->getNanIface(iface_name, &retrieved_iface).isOk());
EXPECT_NE(nullptr, retrieved_iface.get());
std::string invalid_name = iface_name + "0";
std::shared_ptr<IWifiNanIface> invalid_iface;
auto status = wifi_chip_->getNanIface(invalid_name, &invalid_iface);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_EQ(nullptr, invalid_iface.get());
}
/*
* RemoveStaIface
* Configures the chip in STA mode and creates an iface. Then removes
* the iface object using the correct name and ensures that any other
* name doesn't remove the iface.
*/
TEST_P(WifiChipAidlTest, RemoveStaIface) {
std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
std::string iface_name = getStaIfaceName(iface);
std::string invalid_name = iface_name + "0";
auto status = wifi_chip_->removeStaIface(invalid_name);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_TRUE(wifi_chip_->removeStaIface(iface_name).isOk());
// No such iface exists now, so this should return failure.
EXPECT_FALSE(wifi_chip_->removeStaIface(iface_name).isOk());
}
/*
* RemoveP2pIface
*/
TEST_P(WifiChipAidlTest, RemoveP2pIface) {
std::shared_ptr<IWifiP2pIface> iface = configureChipForP2pAndGetIface();
std::string iface_name = getP2pIfaceName(iface);
std::string invalid_name = iface_name + "0";
auto status = wifi_chip_->removeP2pIface(invalid_name);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_TRUE(wifi_chip_->removeP2pIface(iface_name).isOk());
// No such iface exists now, so this should return failure.
EXPECT_FALSE(wifi_chip_->removeP2pIface(iface_name).isOk());
}
/*
* RemoveApIface
*/
TEST_P(WifiChipAidlTest, RemoveApIface) {
std::shared_ptr<IWifiApIface> iface = configureChipForApAndGetIface();
std::string iface_name = getApIfaceName(iface);
std::string invalid_name = iface_name + "0";
auto status = wifi_chip_->removeApIface(invalid_name);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_TRUE(wifi_chip_->removeApIface(iface_name).isOk());
// No such iface exists now, so this should return failure.
EXPECT_FALSE(wifi_chip_->removeApIface(iface_name).isOk());
}
/*
* RemoveNanIface
*/
TEST_P(WifiChipAidlTest, RemoveNanIface) {
std::shared_ptr<IWifiNanIface> iface = configureChipForNanAndGetIface();
std::string iface_name = getNanIfaceName(iface);
std::string invalid_name = iface_name + "0";
auto status = wifi_chip_->removeNanIface(invalid_name);
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
EXPECT_TRUE(wifi_chip_->removeNanIface(iface_name).isOk());
// No such iface exists now, so this should return failure.
EXPECT_FALSE(wifi_chip_->removeNanIface(iface_name).isOk());
}
/*
* CreateRttController
*/
TEST_P(WifiChipAidlTest, CreateRttController) {
std::shared_ptr<IWifiStaIface> iface = configureChipForStaAndGetIface();
std::shared_ptr<IWifiRttController> rtt_controller;
auto status = wifi_chip_->createRttController(iface, &rtt_controller);
if (status.isOk()) {
EXPECT_NE(nullptr, rtt_controller.get());
} else {
EXPECT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
}
/**
* CreateBridgedApIface & RemoveIfaceInstanceFromBridgedApIface
*/
TEST_P(WifiChipAidlTest, CreateBridgedApIfaceAndremoveIfaceInstanceFromBridgedApIfaceTest) {
bool isBridgedSupport = testing::checkSubstringInCommandOutput(
"/system/bin/cmd wifi get-softap-supported-features",
"wifi_softap_bridged_ap_supported");
if (!isBridgedSupport) {
GTEST_SKIP() << "Missing Bridged AP support";
}
std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
ASSERT_NE(nullptr, wifi_chip.get());
std::shared_ptr<IWifiApIface> wifi_ap_iface = getBridgedWifiApIface(wifi_chip);
ASSERT_NE(nullptr, wifi_ap_iface.get());
std::string br_name;
std::vector<std::string> instances;
EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
EXPECT_EQ(instances.size(), 2);
std::vector<std::string> instances_after_remove;
EXPECT_TRUE(wifi_chip->removeIfaceInstanceFromBridgedApIface(br_name, instances[0]).isOk());
EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances_after_remove).isOk());
EXPECT_EQ(instances_after_remove.size(), 1);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiChipAidlTest);
INSTANTIATE_TEST_SUITE_P(WifiTest, WifiChipAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
android::PrintInstanceNameToString);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
android::ProcessState::self()->startThreadPool();
return RUN_ALL_TESTS();
}

627
wifi/aidl/vts/functional/wifi_nan_iface_aidl_test.cpp Normal file
View File

@@ -0,0 +1,627 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Staache 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 <vector>
#include <VtsCoreUtil.h>
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/wifi/BnWifi.h>
#include <aidl/android/hardware/wifi/BnWifiNanIfaceEventCallback.h>
#include <aidl/android/hardware/wifi/NanBandIndex.h>
#include <android/binder_manager.h>
#include <android/binder_status.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include "wifi_aidl_test_utils.h"
using aidl::android::hardware::wifi::BnWifiNanIfaceEventCallback;
using aidl::android::hardware::wifi::IWifiNanIface;
using aidl::android::hardware::wifi::NanBandIndex;
using aidl::android::hardware::wifi::NanBandSpecificConfig;
using aidl::android::hardware::wifi::NanCapabilities;
using aidl::android::hardware::wifi::NanClusterEventInd;
using aidl::android::hardware::wifi::NanConfigRequest;
using aidl::android::hardware::wifi::NanConfigRequestSupplemental;
using aidl::android::hardware::wifi::NanDataPathConfirmInd;
using aidl::android::hardware::wifi::NanDataPathRequestInd;
using aidl::android::hardware::wifi::NanDataPathScheduleUpdateInd;
using aidl::android::hardware::wifi::NanDataPathSecurityType;
using aidl::android::hardware::wifi::NanEnableRequest;
using aidl::android::hardware::wifi::NanFollowupReceivedInd;
using aidl::android::hardware::wifi::NanInitiateDataPathRequest;
using aidl::android::hardware::wifi::NanMatchAlg;
using aidl::android::hardware::wifi::NanMatchInd;
using aidl::android::hardware::wifi::NanPublishRequest;
using aidl::android::hardware::wifi::NanPublishType;
using aidl::android::hardware::wifi::NanRespondToDataPathIndicationRequest;
using aidl::android::hardware::wifi::NanStatus;
using aidl::android::hardware::wifi::NanStatusCode;
using aidl::android::hardware::wifi::NanTxType;
#define TIMEOUT_PERIOD 10
class WifiNanIfaceAidlTest : public testing::TestWithParam<std::string> {
public:
void SetUp() override {
if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware"))
GTEST_SKIP() << "Skipping this test since NAN is not supported.";
stopWifiService(getInstanceName());
wifi_nan_iface_ = getWifiNanIface(getInstanceName());
ASSERT_NE(nullptr, wifi_nan_iface_.get());
std::shared_ptr<WifiNanIfaceEventCallback> callback =
ndk::SharedRefBase::make<WifiNanIfaceEventCallback>(*this);
EXPECT_TRUE(wifi_nan_iface_->registerEventCallback(callback).isOk());
}
void TearDown() override { stopWifiService(getInstanceName()); }
// Used as a mechanism to inform the test about data/event callbacks.
inline void notify() {
std::unique_lock<std::mutex> lock(mtx_);
count_++;
cv_.notify_one();
}
enum CallbackType {
INVALID = -2,
ANY_CALLBACK = -1,
NOTIFY_CAPABILITIES_RESPONSE = 0,
NOTIFY_ENABLE_RESPONSE,
NOTIFY_CONFIG_RESPONSE,
NOTIFY_DISABLE_RESPONSE,
NOTIFY_START_PUBLISH_RESPONSE,
NOTIFY_STOP_PUBLISH_RESPONSE,
NOTIFY_START_SUBSCRIBE_RESPONSE,
NOTIFY_STOP_SUBSCRIBE_RESPONSE,
NOTIFY_TRANSMIT_FOLLOWUP_RESPONSE,
NOTIFY_CREATE_DATA_INTERFACE_RESPONSE,
NOTIFY_DELETE_DATA_INTERFACE_RESPONSE,
NOTIFY_INITIATE_DATA_PATH_RESPONSE,
NOTIFY_RESPOND_TO_DATA_PATH_INDICATION_RESPONSE,
NOTIFY_TERMINATE_DATA_PATH_RESPONSE,
EVENT_CLUSTER_EVENT,
EVENT_DISABLED,
EVENT_PUBLISH_TERMINATED,
EVENT_SUBSCRIBE_TERMINATED,
EVENT_MATCH,
EVENT_MATCH_EXPIRED,
EVENT_FOLLOWUP_RECEIVED,
EVENT_TRANSMIT_FOLLOWUP,
EVENT_DATA_PATH_REQUEST,
EVENT_DATA_PATH_CONFIRM,
EVENT_DATA_PATH_TERMINATED,
EVENT_DATA_PATH_SCHEDULE_UPDATE,
};
// Test code calls this function to wait for data/event callback.
// Must set callbackType = INVALID before calling this function.
inline std::cv_status wait(CallbackType waitForCallbackType) {
std::unique_lock<std::mutex> lock(mtx_);
EXPECT_NE(INVALID, waitForCallbackType);
std::cv_status status = std::cv_status::no_timeout;
auto now = std::chrono::system_clock::now();
while (count_ == 0) {
status = cv_.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
if (status == std::cv_status::timeout) return status;
if (waitForCallbackType != ANY_CALLBACK && callback_type_ != INVALID &&
callback_type_ != waitForCallbackType) {
count_--;
}
}
count_--;
return status;
}
class WifiNanIfaceEventCallback : public BnWifiNanIfaceEventCallback {
public:
WifiNanIfaceEventCallback(WifiNanIfaceAidlTest& parent) : parent_(parent){};
::ndk::ScopedAStatus eventClusterEvent(const NanClusterEventInd& event) override {
parent_.callback_type_ = EVENT_CLUSTER_EVENT;
parent_.nan_cluster_event_ind_ = event;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventDataPathConfirm(const NanDataPathConfirmInd& event) override {
parent_.callback_type_ = EVENT_DATA_PATH_CONFIRM;
parent_.nan_data_path_confirm_ind_ = event;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventDataPathRequest(const NanDataPathRequestInd& event) override {
parent_.callback_type_ = EVENT_DATA_PATH_REQUEST;
parent_.nan_data_path_request_ind_ = event;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventDataPathScheduleUpdate(
const NanDataPathScheduleUpdateInd& event) override {
parent_.callback_type_ = EVENT_DATA_PATH_SCHEDULE_UPDATE;
parent_.nan_data_path_schedule_update_ind_ = event;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventDataPathTerminated(int32_t ndpInstanceId) override {
parent_.callback_type_ = EVENT_DATA_PATH_TERMINATED;
parent_.ndp_instance_id_ = ndpInstanceId;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventDisabled(const NanStatus& status) override {
parent_.callback_type_ = EVENT_DISABLED;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventFollowupReceived(const NanFollowupReceivedInd& event) override {
parent_.callback_type_ = EVENT_FOLLOWUP_RECEIVED;
parent_.nan_followup_received_ind_ = event;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventMatch(const NanMatchInd& event) override {
parent_.callback_type_ = EVENT_MATCH;
parent_.nan_match_ind_ = event;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventMatchExpired(int8_t discoverySessionId, int32_t peerId) override {
parent_.callback_type_ = EVENT_MATCH_EXPIRED;
parent_.session_id_ = discoverySessionId;
parent_.peer_id_ = peerId;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventPublishTerminated(int8_t sessionId,
const NanStatus& status) override {
parent_.callback_type_ = EVENT_PUBLISH_TERMINATED;
parent_.session_id_ = sessionId;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventSubscribeTerminated(int8_t sessionId,
const NanStatus& status) override {
parent_.callback_type_ = EVENT_SUBSCRIBE_TERMINATED;
parent_.session_id_ = sessionId;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus eventTransmitFollowup(char16_t id, const NanStatus& status) override {
parent_.callback_type_ = EVENT_TRANSMIT_FOLLOWUP;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyCapabilitiesResponse(
char16_t id, const NanStatus& status,
const NanCapabilities& capabilities) override {
parent_.callback_type_ = NOTIFY_CAPABILITIES_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.capabilities_ = capabilities;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyConfigResponse(char16_t id, const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_CONFIG_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyCreateDataInterfaceResponse(char16_t id,
const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_CREATE_DATA_INTERFACE_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyDeleteDataInterfaceResponse(char16_t id,
const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_DELETE_DATA_INTERFACE_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyDisableResponse(char16_t id, const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_DISABLE_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyEnableResponse(char16_t id, const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_ENABLE_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyInitiateDataPathResponse(char16_t id, const NanStatus& status,
int32_t ndpInstanceId) override {
parent_.callback_type_ = NOTIFY_INITIATE_DATA_PATH_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.ndp_instance_id_ = ndpInstanceId;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyRespondToDataPathIndicationResponse(
char16_t id, const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_RESPOND_TO_DATA_PATH_INDICATION_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyStartPublishResponse(char16_t id, const NanStatus& status,
int8_t sessionId) override {
parent_.callback_type_ = NOTIFY_START_PUBLISH_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.session_id_ = sessionId;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyStartSubscribeResponse(char16_t id, const NanStatus& status,
int8_t sessionId) override {
parent_.callback_type_ = NOTIFY_START_SUBSCRIBE_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.session_id_ = sessionId;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyStopPublishResponse(char16_t id,
const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_STOP_PUBLISH_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyStopSubscribeResponse(char16_t id,
const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_STOP_SUBSCRIBE_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyTerminateDataPathResponse(char16_t id,
const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_TERMINATE_DATA_PATH_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus notifyTransmitFollowupResponse(char16_t id,
const NanStatus& status) override {
parent_.callback_type_ = NOTIFY_TRANSMIT_FOLLOWUP_RESPONSE;
parent_.id_ = id;
parent_.status_ = status;
parent_.notify();
return ndk::ScopedAStatus::ok();
}
private:
WifiNanIfaceAidlTest& parent_;
};
protected:
std::shared_ptr<IWifiNanIface> wifi_nan_iface_;
CallbackType callback_type_;
uint16_t id_;
uint8_t session_id_;
uint32_t ndp_instance_id_;
uint32_t peer_id_;
NanCapabilities capabilities_;
NanClusterEventInd nan_cluster_event_ind_;
NanDataPathConfirmInd nan_data_path_confirm_ind_;
NanDataPathRequestInd nan_data_path_request_ind_;
NanDataPathScheduleUpdateInd nan_data_path_schedule_update_ind_;
NanFollowupReceivedInd nan_followup_received_ind_;
NanMatchInd nan_match_ind_;
NanStatus status_;
const char* getInstanceName() { return GetParam().c_str(); }
private:
// synchronization objects
std::mutex mtx_;
std::condition_variable cv_;
int count_ = 0;
};
/*
* FailOnIfaceInvalid
* Ensure that API calls to an interface fail with code ERROR_WIFI_IFACE_INVALID
* after wifi is disabled.
*/
TEST_P(WifiNanIfaceAidlTest, FailOnIfaceInvalid) {
stopWifiService(getInstanceName());
sleep(5); // Ensure that all chips/interfaces are invalidated.
auto status = wifi_nan_iface_->getCapabilitiesRequest(0);
ASSERT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_WIFI_IFACE_INVALID));
}
/*
* EnableRequest - Invalid Args
*/
TEST_P(WifiNanIfaceAidlTest, EnableRequest_InvalidArgs) {
uint16_t inputCmdId = 10;
callback_type_ = INVALID;
NanEnableRequest nanEnableRequest = {};
NanConfigRequestSupplemental nanConfigRequestSupp = {};
auto status =
wifi_nan_iface_->enableRequest(inputCmdId, nanEnableRequest, nanConfigRequestSupp);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_TRUE(status.isOk());
// Wait for a callback.
ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_ENABLE_RESPONSE));
ASSERT_EQ(NOTIFY_ENABLE_RESPONSE, callback_type_);
ASSERT_EQ(id_, inputCmdId);
ASSERT_EQ(status_.status, NanStatusCode::INVALID_ARGS);
}
}
/*
* ConfigRequest - Invalid Args
*/
TEST_P(WifiNanIfaceAidlTest, ConfigRequest_InvalidArgs) {
uint16_t inputCmdId = 10;
callback_type_ = INVALID;
NanConfigRequest nanConfigRequest = {};
NanConfigRequestSupplemental nanConfigRequestSupp = {};
auto status =
wifi_nan_iface_->configRequest(inputCmdId, nanConfigRequest, nanConfigRequestSupp);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_TRUE(status.isOk());
// Wait for a callback.
ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_CONFIG_RESPONSE));
ASSERT_EQ(NOTIFY_CONFIG_RESPONSE, callback_type_);
ASSERT_EQ(id_, inputCmdId);
ASSERT_EQ(status_.status, NanStatusCode::INVALID_ARGS);
}
}
/*
* EnableRequest - Invalid Args in Shim Conversion
*/
TEST_P(WifiNanIfaceAidlTest, EnableRequest_InvalidShimArgs) {
uint16_t inputCmdId = 10;
NanEnableRequest nanEnableRequest = {};
nanEnableRequest.configParams.numberOfPublishServiceIdsInBeacon = -15; // must be > 0
NanConfigRequestSupplemental nanConfigRequestSupp = {};
auto status =
wifi_nan_iface_->enableRequest(inputCmdId, nanEnableRequest, nanConfigRequestSupp);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
}
}
/*
* ConfigRequest - Invalid Args in Shim Conversion
*/
TEST_P(WifiNanIfaceAidlTest, ConfigRequest_InvalidShimArgs) {
uint16_t inputCmdId = 10;
NanConfigRequest nanConfigRequest = {};
nanConfigRequest.numberOfPublishServiceIdsInBeacon = -15; // must be > 0
NanConfigRequestSupplemental nanConfigRequestSupp = {};
auto status =
wifi_nan_iface_->configRequest(inputCmdId, nanConfigRequest, nanConfigRequestSupp);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_TRUE(checkStatusCode(&status, WifiStatusCode::ERROR_INVALID_ARGS));
}
}
/*
* NotifyCapabilitiesResponse
*/
TEST_P(WifiNanIfaceAidlTest, NotifyCapabilitiesResponse) {
uint16_t inputCmdId = 10;
callback_type_ = INVALID;
EXPECT_TRUE(wifi_nan_iface_->getCapabilitiesRequest(inputCmdId).isOk());
// Wait for a callback.
ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_CAPABILITIES_RESPONSE));
ASSERT_EQ(NOTIFY_CAPABILITIES_RESPONSE, callback_type_);
ASSERT_EQ(id_, inputCmdId);
ASSERT_EQ(status_.status, NanStatusCode::SUCCESS);
// Check for reasonable capability values.
EXPECT_GT(capabilities_.maxConcurrentClusters, 0);
EXPECT_GT(capabilities_.maxPublishes, 0);
EXPECT_GT(capabilities_.maxSubscribes, 0);
EXPECT_EQ(capabilities_.maxServiceNameLen, 255);
EXPECT_EQ(capabilities_.maxMatchFilterLen, 255);
EXPECT_GT(capabilities_.maxTotalMatchFilterLen, 255);
EXPECT_EQ(capabilities_.maxServiceSpecificInfoLen, 255);
EXPECT_GE(capabilities_.maxExtendedServiceSpecificInfoLen, 255);
EXPECT_GT(capabilities_.maxNdiInterfaces, 0);
EXPECT_GT(capabilities_.maxNdpSessions, 0);
EXPECT_GT(capabilities_.maxAppInfoLen, 0);
EXPECT_GT(capabilities_.maxQueuedTransmitFollowupMsgs, 0);
EXPECT_GT(capabilities_.maxSubscribeInterfaceAddresses, 0);
EXPECT_NE(static_cast<int32_t>(capabilities_.supportedCipherSuites), 0);
}
/*
* StartPublishRequest
*/
TEST_P(WifiNanIfaceAidlTest, StartPublishRequest) {
uint16_t inputCmdId = 10;
NanBandSpecificConfig config24 = {};
config24.rssiClose = 60;
config24.rssiMiddle = 70;
config24.rssiCloseProximity = 60;
config24.dwellTimeMs = 200;
config24.scanPeriodSec = 20;
config24.validDiscoveryWindowIntervalVal = false;
config24.discoveryWindowIntervalVal = 0;
NanBandSpecificConfig config5 = {};
config5.rssiClose = 60;
config5.rssiMiddle = 75;
config5.rssiCloseProximity = 60;
config5.dwellTimeMs = 200;
config5.scanPeriodSec = 20;
config5.validDiscoveryWindowIntervalVal = false;
config5.discoveryWindowIntervalVal = 0;
NanEnableRequest req = {};
req.operateInBand[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = true;
req.operateInBand[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = false;
req.hopCountMax = 2;
req.configParams.masterPref = 0;
req.configParams.disableDiscoveryAddressChangeIndication = true;
req.configParams.disableStartedClusterIndication = true;
req.configParams.disableJoinedClusterIndication = true;
req.configParams.includePublishServiceIdsInBeacon = true;
req.configParams.numberOfPublishServiceIdsInBeacon = 0;
req.configParams.includeSubscribeServiceIdsInBeacon = true;
req.configParams.numberOfSubscribeServiceIdsInBeacon = 0;
req.configParams.rssiWindowSize = 8;
req.configParams.macAddressRandomizationIntervalSec = 1800;
req.configParams.bandSpecificConfig[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] =
config24;
req.configParams.bandSpecificConfig[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] =
config5;
req.debugConfigs.validClusterIdVals = true;
req.debugConfigs.clusterIdTopRangeVal = 65535;
req.debugConfigs.clusterIdBottomRangeVal = 0;
req.debugConfigs.validIntfAddrVal = false;
req.debugConfigs.validOuiVal = false;
req.debugConfigs.ouiVal = 0;
req.debugConfigs.validRandomFactorForceVal = false;
req.debugConfigs.randomFactorForceVal = 0;
req.debugConfigs.validHopCountForceVal = false;
req.debugConfigs.hopCountForceVal = 0;
req.debugConfigs.validDiscoveryChannelVal = false;
req.debugConfigs.discoveryChannelMhzVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = 0;
req.debugConfigs.discoveryChannelMhzVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = 0;
req.debugConfigs.validUseBeaconsInBandVal = false;
req.debugConfigs.useBeaconsInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = true;
req.debugConfigs.useBeaconsInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = true;
req.debugConfigs.validUseSdfInBandVal = false;
req.debugConfigs.useSdfInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_24GHZ)] = true;
req.debugConfigs.useSdfInBandVal[static_cast<int32_t>(NanBandIndex::NAN_BAND_5GHZ)] = true;
NanConfigRequestSupplemental nanConfigRequestSupp = {};
nanConfigRequestSupp.discoveryBeaconIntervalMs = 20;
nanConfigRequestSupp.numberOfSpatialStreamsInDiscovery = 0;
nanConfigRequestSupp.enableDiscoveryWindowEarlyTermination = false;
callback_type_ = INVALID;
auto status = wifi_nan_iface_->enableRequest(inputCmdId, req, nanConfigRequestSupp);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_TRUE(status.isOk());
// Wait for a callback.
ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_ENABLE_RESPONSE));
ASSERT_EQ(NOTIFY_ENABLE_RESPONSE, callback_type_);
ASSERT_EQ(id_, inputCmdId);
ASSERT_EQ(status_.status, NanStatusCode::SUCCESS);
}
NanPublishRequest nanPublishRequest = {};
nanPublishRequest.baseConfigs.sessionId = 0;
nanPublishRequest.baseConfigs.ttlSec = 0;
nanPublishRequest.baseConfigs.discoveryWindowPeriod = 1;
nanPublishRequest.baseConfigs.discoveryCount = 0;
nanPublishRequest.baseConfigs.serviceName = {97};
nanPublishRequest.baseConfigs.discoveryMatchIndicator = NanMatchAlg::MATCH_NEVER;
nanPublishRequest.baseConfigs.useRssiThreshold = false;
nanPublishRequest.baseConfigs.disableDiscoveryTerminationIndication = false;
nanPublishRequest.baseConfigs.disableMatchExpirationIndication = true;
nanPublishRequest.baseConfigs.disableFollowupReceivedIndication = false;
nanPublishRequest.baseConfigs.securityConfig.securityType = NanDataPathSecurityType::OPEN;
nanPublishRequest.autoAcceptDataPathRequests = false;
nanPublishRequest.publishType = NanPublishType::UNSOLICITED;
nanPublishRequest.txType = NanTxType::BROADCAST;
status = wifi_nan_iface_->startPublishRequest(inputCmdId + 1, nanPublishRequest);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_TRUE(status.isOk());
// Wait for a callback.
ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_START_PUBLISH_RESPONSE));
ASSERT_EQ(NOTIFY_START_PUBLISH_RESPONSE, callback_type_);
ASSERT_EQ(id_, inputCmdId + 1);
ASSERT_EQ(status_.status, NanStatusCode::SUCCESS);
}
}
/*
* RespondToDataPathIndicationRequest - Invalid Args
*/
TEST_P(WifiNanIfaceAidlTest, RespondToDataPathIndicationRequest_InvalidArgs) {
uint16_t inputCmdId = 10;
callback_type_ = INVALID;
NanRespondToDataPathIndicationRequest nanRespondToDataPathIndicationRequest = {};
nanRespondToDataPathIndicationRequest.ifaceName = "AwareInterfaceNameTooLong";
auto status = wifi_nan_iface_->respondToDataPathIndicationRequest(
inputCmdId, nanRespondToDataPathIndicationRequest);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_EQ(status.getServiceSpecificError(),
static_cast<int32_t>(WifiStatusCode::ERROR_INVALID_ARGS));
}
}
/*
* InitiateDataPathRequest - Invalid Args
*/
TEST_P(WifiNanIfaceAidlTest, InitiateDataPathRequest_InvalidArgs) {
uint16_t inputCmdId = 10;
callback_type_ = INVALID;
NanInitiateDataPathRequest nanInitiateDataPathRequest = {};
nanInitiateDataPathRequest.ifaceName = "AwareInterfaceNameTooLong";
auto status = wifi_nan_iface_->initiateDataPathRequest(inputCmdId, nanInitiateDataPathRequest);
if (!checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
ASSERT_EQ(status.getServiceSpecificError(),
static_cast<int32_t>(WifiStatusCode::ERROR_INVALID_ARGS));
}
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiNanIfaceAidlTest);
INSTANTIATE_TEST_SUITE_P(WifiTest, WifiNanIfaceAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
android::PrintInstanceNameToString);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
android::ProcessState::self()->startThreadPool();
return RUN_ALL_TESTS();
}

234
wifi/aidl/vts/functional/wifi_rtt_controller_aidl_test.cpp Normal file
View File

@@ -0,0 +1,234 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Staache 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 <vector>
#include <VtsCoreUtil.h>
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/wifi/BnWifi.h>
#include <aidl/android/hardware/wifi/BnWifiRttControllerEventCallback.h>
#include <android/binder_manager.h>
#include <android/binder_status.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include "wifi_aidl_test_utils.h"
using aidl::android::hardware::wifi::BnWifiRttControllerEventCallback;
using aidl::android::hardware::wifi::IWifiRttController;
using aidl::android::hardware::wifi::RttBw;
using aidl::android::hardware::wifi::RttCapabilities;
using aidl::android::hardware::wifi::RttConfig;
using aidl::android::hardware::wifi::RttPeerType;
using aidl::android::hardware::wifi::RttPreamble;
using aidl::android::hardware::wifi::RttResponder;
using aidl::android::hardware::wifi::RttResult;
using aidl::android::hardware::wifi::RttType;
using aidl::android::hardware::wifi::WifiChannelInfo;
using aidl::android::hardware::wifi::WifiChannelWidthInMhz;
using aidl::android::hardware::wifi::WifiStatusCode;
class WifiRttControllerAidlTest : public testing::TestWithParam<std::string> {
public:
void SetUp() override {
if (!::testing::deviceSupportsFeature("android.hardware.wifi.rtt"))
GTEST_SKIP() << "Skipping this test since RTT is not supported.";
stopWifiService(getInstanceName());
wifi_rtt_controller_ = getWifiRttController();
ASSERT_NE(nullptr, wifi_rtt_controller_.get());
// Check RTT support before we run the test.
RttCapabilities caps = {};
auto status = wifi_rtt_controller_->getCapabilities(&caps);
if (checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED)) {
GTEST_SKIP() << "Skipping this test since RTT is not supported.";
}
}
void TearDown() override { stopWifiService(getInstanceName()); }
protected:
std::shared_ptr<IWifiRttController> getWifiRttController() {
std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
EXPECT_NE(nullptr, wifi_chip.get());
std::shared_ptr<IWifiStaIface> wifi_sta_iface = getWifiStaIface(getInstanceName());
EXPECT_NE(nullptr, wifi_sta_iface.get());
std::shared_ptr<IWifiRttController> rtt_controller;
EXPECT_TRUE(wifi_chip->createRttController(wifi_sta_iface, &rtt_controller).isOk());
EXPECT_NE(nullptr, rtt_controller.get());
return rtt_controller;
}
std::shared_ptr<IWifiRttController> wifi_rtt_controller_;
private:
const char* getInstanceName() { return GetParam().c_str(); }
};
class WifiRttControllerEventCallback : public BnWifiRttControllerEventCallback {
public:
WifiRttControllerEventCallback() = default;
::ndk::ScopedAStatus onResults(int /* cmdId */,
const std::vector<RttResult>& /* results */) override {
return ndk::ScopedAStatus::ok();
}
};
/*
* RegisterEventCallback
*
* Note: it is not feasible to test the invocation of the callback function,
* since events are triggered internally in the HAL implementation and cannot be
* triggered from the test case.
*/
TEST_P(WifiRttControllerAidlTest, RegisterEventCallback) {
std::shared_ptr<WifiRttControllerEventCallback> callback =
ndk::SharedRefBase::make<WifiRttControllerEventCallback>();
ASSERT_NE(nullptr, callback.get());
EXPECT_TRUE(wifi_rtt_controller_->registerEventCallback(callback).isOk());
}
/*
* GetCapabilities
*/
TEST_P(WifiRttControllerAidlTest, GetCapabilities) {
RttCapabilities caps = {};
EXPECT_TRUE(wifi_rtt_controller_->getCapabilities(&caps).isOk());
}
/*
* GetResponderInfo
*/
TEST_P(WifiRttControllerAidlTest, GetResponderInfo) {
RttResponder responder = {};
EXPECT_TRUE(wifi_rtt_controller_->getResponderInfo(&responder).isOk());
}
/*
* EnableResponder
*/
TEST_P(WifiRttControllerAidlTest, EnableResponder) {
int cmdId = 55;
WifiChannelInfo channelInfo;
channelInfo.width = WifiChannelWidthInMhz::WIDTH_80;
channelInfo.centerFreq = 5660;
channelInfo.centerFreq0 = 5660;
channelInfo.centerFreq1 = 0;
RttResponder responder = {};
EXPECT_TRUE(wifi_rtt_controller_->getResponderInfo(&responder).isOk());
EXPECT_TRUE(wifi_rtt_controller_->enableResponder(cmdId, channelInfo, 10, responder).isOk());
}
/*
* Request2SidedRangeMeasurement
* Tests the two sided ranging - 802.11mc FTM protocol.
*/
TEST_P(WifiRttControllerAidlTest, Request2SidedRangeMeasurement) {
RttCapabilities caps = {};
EXPECT_TRUE(wifi_rtt_controller_->getCapabilities(&caps).isOk());
if (!caps.rttFtmSupported) {
GTEST_SKIP() << "Skipping two sided RTT since driver/fw does not support";
}
RttConfig config;
config.addr = {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05}};
config.type = RttType::TWO_SIDED;
config.peer = RttPeerType::AP;
config.channel.width = WifiChannelWidthInMhz::WIDTH_80;
config.channel.centerFreq = 5180;
config.channel.centerFreq0 = 5210;
config.channel.centerFreq1 = 0;
config.bw = RttBw::BW_20MHZ;
config.preamble = RttPreamble::HT;
config.mustRequestLci = false;
config.mustRequestLcr = false;
config.burstPeriod = 0;
config.numBurst = 0;
config.numFramesPerBurst = 8;
config.numRetriesPerRttFrame = 0;
config.numRetriesPerFtmr = 0;
config.burstDuration = 9;
int cmdId = 55;
std::vector<RttConfig> configs = {config};
EXPECT_TRUE(wifi_rtt_controller_->rangeRequest(cmdId, configs).isOk());
// Sleep for 2 seconds to wait for driver/firmware to complete RTT.
sleep(2);
}
/*
* RangeRequest
*/
TEST_P(WifiRttControllerAidlTest, RangeRequest) {
RttCapabilities caps = {};
EXPECT_TRUE(wifi_rtt_controller_->getCapabilities(&caps).isOk());
if (!caps.rttOneSidedSupported) {
GTEST_SKIP() << "Skipping one sided RTT since driver/fw does not support";
}
// Get the highest supported preamble.
int preamble = 1;
int caps_preamble_support = static_cast<int>(caps.preambleSupport);
caps_preamble_support >>= 1;
while (caps_preamble_support != 0) {
caps_preamble_support >>= 1;
preamble <<= 1;
}
RttConfig config;
config.addr = {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05}};
config.type = RttType::ONE_SIDED;
config.peer = RttPeerType::AP;
config.channel.width = WifiChannelWidthInMhz::WIDTH_80;
config.channel.centerFreq = 5765;
config.channel.centerFreq0 = 5775;
config.channel.centerFreq1 = 0;
config.bw = RttBw::BW_80MHZ;
config.preamble = static_cast<RttPreamble>(preamble);
config.mustRequestLci = false;
config.mustRequestLcr = false;
config.burstPeriod = 0;
config.numBurst = 0;
config.numFramesPerBurst = 8;
config.numRetriesPerRttFrame = 3;
config.numRetriesPerFtmr = 3;
config.burstDuration = 9;
int cmdId = 55;
std::vector<RttConfig> configs = {config};
EXPECT_TRUE(wifi_rtt_controller_->rangeRequest(cmdId, configs).isOk());
// Sleep for 2 seconds to wait for driver/firmware to complete RTT.
sleep(2);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiRttControllerAidlTest);
INSTANTIATE_TEST_SUITE_P(WifiTest, WifiRttControllerAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
android::PrintInstanceNameToString);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
android::ProcessState::self()->startThreadPool();
return RUN_ALL_TESTS();
}

282
wifi/aidl/vts/functional/wifi_sta_iface_aidl_test.cpp Normal file
View File

@@ -0,0 +1,282 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Staache 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 <vector>
#include <VtsCoreUtil.h>
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/wifi/BnWifi.h>
#include <android/binder_manager.h>
#include <android/binder_status.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include "wifi_aidl_test_utils.h"
using aidl::android::hardware::wifi::IWifi;
using aidl::android::hardware::wifi::IWifiStaIface;
using aidl::android::hardware::wifi::MacAddress;
using aidl::android::hardware::wifi::Ssid;
using aidl::android::hardware::wifi::StaApfPacketFilterCapabilities;
using aidl::android::hardware::wifi::StaBackgroundScanCapabilities;
using aidl::android::hardware::wifi::StaLinkLayerStats;
using aidl::android::hardware::wifi::StaRoamingCapabilities;
using aidl::android::hardware::wifi::StaRoamingConfig;
using aidl::android::hardware::wifi::StaRoamingState;
using aidl::android::hardware::wifi::WifiBand;
using aidl::android::hardware::wifi::WifiDebugRxPacketFateReport;
using aidl::android::hardware::wifi::WifiDebugTxPacketFateReport;
using aidl::android::hardware::wifi::WifiStatusCode;
class WifiStaIfaceAidlTest : public testing::TestWithParam<std::string> {
public:
void SetUp() override {
stopWifiService(getInstanceName());
wifi_sta_iface_ = getWifiStaIface(getInstanceName());
ASSERT_NE(nullptr, wifi_sta_iface_.get());
}
void TearDown() override { stopWifiService(getInstanceName()); }
protected:
bool isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask expected) {
IWifiStaIface::StaIfaceCapabilityMask caps = {};
EXPECT_TRUE(wifi_sta_iface_->getCapabilities(&caps).isOk());
return static_cast<uint32_t>(caps) & static_cast<uint32_t>(expected);
}
ndk::ScopedAStatus createStaIface(std::shared_ptr<IWifiStaIface>* sta_iface) {
std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
EXPECT_NE(nullptr, wifi_chip.get());
return wifi_chip->createStaIface(sta_iface);
}
std::shared_ptr<IWifiStaIface> wifi_sta_iface_;
private:
const char* getInstanceName() { return GetParam().c_str(); }
};
/*
* GetFactoryMacAddress
* Ensures that calls to getFactoryMacAddress will retrieve a non-zero MAC.
*/
TEST_P(WifiStaIfaceAidlTest, GetFactoryMacAddress) {
std::array<uint8_t, 6> mac;
EXPECT_TRUE(wifi_sta_iface_->getFactoryMacAddress(&mac).isOk());
std::array<uint8_t, 6> all_zero_mac = {0, 0, 0, 0, 0, 0};
EXPECT_NE(mac, all_zero_mac);
}
/*
* GetCapabilities
*/
TEST_P(WifiStaIfaceAidlTest, GetCapabilities) {
IWifiStaIface::StaIfaceCapabilityMask caps = {};
EXPECT_TRUE(wifi_sta_iface_->getCapabilities(&caps).isOk());
EXPECT_NE(static_cast<int32_t>(caps), 0);
}
/*
* GetApfPacketFilterCapabilities
*/
TEST_P(WifiStaIfaceAidlTest, GetApfPacketFilterCapabilities) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::APF)) {
GTEST_SKIP() << "APF packet filter capabilities are not supported.";
}
StaApfPacketFilterCapabilities apf_caps = {};
EXPECT_TRUE(wifi_sta_iface_->getApfPacketFilterCapabilities(&apf_caps).isOk());
}
/*
* GetBackgroundScanCapabilities
*/
TEST_P(WifiStaIfaceAidlTest, GetBackgroundScanCapabilities) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::BACKGROUND_SCAN)) {
GTEST_SKIP() << "Background scan capabilities are not supported.";
}
StaBackgroundScanCapabilities caps = {};
EXPECT_TRUE(wifi_sta_iface_->getBackgroundScanCapabilities(&caps).isOk());
}
/*
* GetValidFrequenciesForBand
* Ensures that we can retrieve valid frequencies for the 2.4 GHz band.
*/
TEST_P(WifiStaIfaceAidlTest, GetValidFrequenciesForBand) {
std::vector<int> freqs;
EXPECT_TRUE(wifi_sta_iface_->getValidFrequenciesForBand(WifiBand::BAND_24GHZ, &freqs).isOk());
EXPECT_NE(freqs.size(), 0);
}
/*
* GetLinkLayerStats
* Ensures that calls to getLinkLayerStats will retrieve a non-empty
* StaLinkLayerStats after link layer stats collection is enabled.
*/
TEST_P(WifiStaIfaceAidlTest, GetLinkLayerStats) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS)) {
GTEST_SKIP() << "Skipping this test since link layer stats are not supported.";
}
// Enable link layer stats collection.
EXPECT_TRUE(wifi_sta_iface_->enableLinkLayerStatsCollection(true).isOk());
// Retrieve link layer stats.
StaLinkLayerStats link_layer_stats = {};
EXPECT_TRUE(wifi_sta_iface_->getLinkLayerStats(&link_layer_stats).isOk());
EXPECT_GT(link_layer_stats.timeStampInMs, 0);
// Try to create a 2nd iface. If successful, it should fill the duty cycle field.
std::shared_ptr<IWifiStaIface> iface;
auto status = createStaIface(&iface);
if (status.isOk()) {
EXPECT_GT(link_layer_stats.iface.timeSliceDutyCycleInPercent, 0);
}
// Disable link layer stats collection.
EXPECT_TRUE(wifi_sta_iface_->disableLinkLayerStatsCollection().isOk());
}
/*
* SetMacAddress
* Ensures that calls to setMacAddress will return successfully.
*/
TEST_P(WifiStaIfaceAidlTest, SetMacAddress) {
std::array<uint8_t, 6> mac = {0x12, 0x22, 0x33, 0x52, 0x10, 0x41};
EXPECT_TRUE(wifi_sta_iface_->setMacAddress(mac).isOk());
}
/*
* SetScanMode
*/
TEST_P(WifiStaIfaceAidlTest, SetScanMode) {
auto status = wifi_sta_iface_->setScanMode(true);
EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
status = wifi_sta_iface_->setScanMode(false);
EXPECT_TRUE(status.isOk() || checkStatusCode(&status, WifiStatusCode::ERROR_NOT_SUPPORTED));
}
/*
* LinkLayerStatsCollection
*/
TEST_P(WifiStaIfaceAidlTest, LinkLayerStatsCollection) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS)) {
GTEST_SKIP() << "Link layer stats collection is not supported.";
}
// Enable link layer stats collection.
EXPECT_TRUE(wifi_sta_iface_->enableLinkLayerStatsCollection(true).isOk());
// Retrieve link layer stats.
StaLinkLayerStats link_layer_stats = {};
EXPECT_TRUE(wifi_sta_iface_->getLinkLayerStats(&link_layer_stats).isOk());
// Disable link layer stats collection.
EXPECT_TRUE(wifi_sta_iface_->disableLinkLayerStatsCollection().isOk());
}
/*
* RSSIMonitoring
* Ensures that calls to startRssiMonitoring and stopRssiMonitoring will fail
* if the device is not connected to an AP.
*/
TEST_P(WifiStaIfaceAidlTest, RSSIMonitoring) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::RSSI_MONITOR)) {
GTEST_SKIP() << "RSSI monitoring is not supported.";
}
const int cmd = 1;
const int maxRssi = -50;
const int minRssi = -90;
// Expected to fail because device is not connected to an AP.
EXPECT_FALSE(wifi_sta_iface_->startRssiMonitoring(cmd, maxRssi, minRssi).isOk());
EXPECT_FALSE(wifi_sta_iface_->stopRssiMonitoring(cmd).isOk());
}
/*
* RoamingControl
*/
TEST_P(WifiStaIfaceAidlTest, RoamingControl) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::CONTROL_ROAMING)) {
GTEST_SKIP() << "Roaming control is not supported.";
}
// Retrieve roaming capabilities.
StaRoamingCapabilities caps = {};
EXPECT_TRUE(wifi_sta_iface_->getRoamingCapabilities(&caps).isOk());
// Set up roaming configuration based on roaming capabilities.
StaRoamingConfig roaming_config = {};
if (caps.maxBlocklistSize > 0) {
MacAddress block_list_entry;
block_list_entry.data = std::array<uint8_t, 6>{{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}};
roaming_config.bssidBlocklist = {block_list_entry};
}
if (caps.maxAllowlistSize > 0) {
Ssid allow_list_entry = {};
allow_list_entry.data = std::array<uint8_t, 32>{{0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC}};
roaming_config.ssidAllowlist = {allow_list_entry};
}
// Configure roaming.
EXPECT_TRUE(wifi_sta_iface_->configureRoaming(roaming_config).isOk());
// Enable roaming.
EXPECT_TRUE(wifi_sta_iface_->setRoamingState(StaRoamingState::ENABLED).isOk());
}
/*
* EnableNDOffload
*/
TEST_P(WifiStaIfaceAidlTest, EnableNDOffload) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::ND_OFFLOAD)) {
GTEST_SKIP() << "ND offload is not supported.";
}
EXPECT_TRUE(wifi_sta_iface_->enableNdOffload(true).isOk());
}
/*
* PacketFateMonitoring
*/
TEST_P(WifiStaIfaceAidlTest, PacketFateMonitoring) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::DEBUG_PACKET_FATE)) {
GTEST_SKIP() << "Packet fate monitoring is not supported.";
}
// Start packet fate monitoring.
EXPECT_TRUE(wifi_sta_iface_->startDebugPacketFateMonitoring().isOk());
// Retrieve packets.
std::vector<WifiDebugRxPacketFateReport> rx_reports;
std::vector<WifiDebugTxPacketFateReport> tx_reports;
EXPECT_TRUE(wifi_sta_iface_->getDebugRxPacketFates(&rx_reports).isOk());
EXPECT_TRUE(wifi_sta_iface_->getDebugTxPacketFates(&tx_reports).isOk());
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiStaIfaceAidlTest);
INSTANTIATE_TEST_SUITE_P(WifiTest, WifiStaIfaceAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),
android::PrintInstanceNameToString);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
android::ProcessState::self()->setThreadPoolMaxThreadCount(1);
android::ProcessState::self()->startThreadPool();
return RUN_ALL_TESTS();
}

8
wifi/apex/Android.bp
View File

@@ -15,7 +15,7 @@ android_app_certificate {
genrule {
name: "gen-android.hardware.wifi.rc",
srcs: [":default-android.hardware.wifi@1.0-service.rc"],
srcs: [":default-android.hardware.wifi-service.rc"],
out: ["com.android.hardware.wifi-service.rc"],
cmd: "sed -e 's@/vendor/bin/@/apex/com.android.hardware.wifi/bin/@' $(in) > $(out)",
}
@@ -28,7 +28,7 @@ prebuilt_etc {
prebuilt_etc {
name: "com.android.hardware.wifi.xml",
src: ":default-android.hardware.wifi@1.0-service.xml",
src: ":default-android.hardware.wifi-service.xml",
installable: false,
}
@@ -43,13 +43,13 @@ apex {
updatable: false,
soc_specific: true,
binaries: [
"android.hardware.wifi@1.0-service",
"android.hardware.wifi-service",
],
prebuilts: [
"com.android.hardware.wifi.rc",
"com.android.hardware.wifi.xml",
],
overrides: [
"android.hardware.wifi@1.0-service",
"android.hardware.wifi-service",
],
}

2
wifi/apex/file_contexts
View File

@@ -1,3 +1,3 @@
(/.*)? u:object_r:vendor_file:s0
/bin/hw/android\.hardware\.wifi@1.0-service u:object_r:hal_wifi_default_exec:s0
/bin/hw/android\.hardware\.wifi-service u:object_r:hal_wifi_default_exec:s0