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

Merge "Wifi: Uprev wifi HAL to 1.6"

Browse Source
This commit is contained in:
Ahmed ElArabawy
2022-01-15 18:52:02 +00:00
committed by Android (Google) Code Review
parent 54ac4fa30b 687ce13059
commit 640c82d41c
70 changed files with 4371 additions and 5608 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
compatibility_matrices/compatibility_matrix.current.xml
View File

@@ -778,7 +778,7 @@
</hal>
<hal format="hidl" optional="true">
<name>android.hardware.wifi</name>
<version>1.3-5</version>
<version>1.3-6</version>
<interface>
<name>IWifi</name>
<instance>default</instance>

227
wifi/1.5/default/hidl_struct_util.h
View File

@@ -1,227 +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.5/IWifiChip.h>
#include <android/hardware/wifi/1.5/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_5 {
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(
IWifiChip::MultiStaUseCase use_case);
bool convertHidlCoexUnsafeChannelToLegacy(
const IWifiChip::CoexUnsafeChannel& hidl_unsafe_channel,
legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel);
bool convertHidlVectorOfCoexUnsafeChannelToLegacy(
const std::vector<IWifiChip::CoexUnsafeChannel>& hidl_unsafe_channels,
std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels);
// 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,
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_4ToLegacy(
const V1_4::NanEnableRequest& hidl_request1,
const NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequest_1_4ToLegacy(
const V1_4::NanConfigRequest& hidl_request1,
const NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanEnableRequest_1_5ToLegacy(
const V1_4::NanEnableRequest& hidl_request1,
const NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequest_1_5ToLegacy(
const V1_4::NanConfigRequest& hidl_request1,
const NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanPublishRequestToLegacy(
const NanPublishRequest& hidl_request,
legacy_hal::NanPublishRequest* legacy_request);
bool convertHidlNanSubscribeRequestToLegacy(
const NanSubscribeRequest& hidl_request,
legacy_hal::NanSubscribeRequest* legacy_request);
bool convertHidlNanTransmitFollowupRequestToLegacy(
const NanTransmitFollowupRequest& hidl_request,
legacy_hal::NanTransmitFollowupRequest* legacy_request);
bool convertHidlNanDataPathInitiatorRequestToLegacy(
const NanInitiateDataPathRequest& hidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request);
bool convertHidlNanDataPathIndicationResponseToLegacy(
const 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,
NanCapabilities* hidl_response);
bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
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_2::NanDataPathConfirmInd* hidl_ind);
bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
V1_2::NanDataPathScheduleUpdateInd* hidl_ind);
// RTT controller conversion methods.
bool convertHidlVectorOfRttConfigToLegacy(
const std::vector<V1_4::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_4::RttResponder& hidl_responder,
legacy_hal::wifi_rtt_responder* legacy_responder);
bool convertHidlWifiChannelInfoToLegacy(
const WifiChannelInfo& hidl_info,
legacy_hal::wifi_channel_info* legacy_info);
bool convertLegacyRttResponderToHidl(
const legacy_hal::wifi_rtt_responder& legacy_responder,
V1_4::RttResponder* hidl_responder);
bool convertLegacyRttCapabilitiesToHidl(
const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
V1_4::RttCapabilities* hidl_capabilities);
bool convertLegacyVectorOfRttResultToHidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
std::vector<V1_4::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_5::WifiUsableChannel>* hidl_usable_channels);
bool convertLegacyPeerInfoStatsToHidl(
const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
StaPeerInfo* hidl_peer_info_stats);
bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
V1_4::WifiRateInfo* hidl_rate);
} // namespace hidl_struct_util
} // namespace implementation
} // namespace V1_5
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_STRUCT_UTIL_H_

162
wifi/1.5/default/tests/wifi_nan_iface_unit_tests.cpp
View File

@@ -1,162 +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_5 {
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 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 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 NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathScheduleUpdate,
Return<void>(const NanDataPathScheduleUpdateInd&));
MOCK_METHOD3(notifyCapabilitiesResponse_1_5,
Return<void>(uint16_t, const WifiNanStatus&,
const 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_5
} // namespace wifi
} // namespace hardware
} // namespace android

1003
wifi/1.5/default/wifi_nan_iface.cpp
View File

File diff suppressed because it is too large Load Diff

212
wifi/1.5/default/wifi_nan_iface.h
View File

@@ -1,212 +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.5/IWifiNanIface.h>
#include <android/hardware/wifi/1.5/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_5 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using namespace android::hardware::wifi::V1_2;
/**
* HIDL interface object used to control a NAN Iface instance.
*/
class WifiNanIface : public V1_5::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 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 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 NanInitiateDataPathRequest& msg,
initiateDataPathRequest_cb hidl_status_cb) override;
Return<void> respondToDataPathIndicationRequest(
uint16_t cmd_id, const 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<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 NanConfigRequestSupplemental& msg2,
enableRequest_1_4_cb hidl_status_cb) override;
Return<void> configRequest_1_5(
uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const NanConfigRequestSupplemental& msg2,
configRequest_1_4_cb hidl_status_cb) override;
Return<void> getCapabilitiesRequest_1_5(
uint16_t cmd_id, getCapabilitiesRequest_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 NanPublishRequest& msg);
WifiStatus stopPublishRequestInternal(uint16_t cmd_id, uint8_t sessionId);
WifiStatus startSubscribeRequestInternal(uint16_t cmd_id,
const 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 NanInitiateDataPathRequest& msg);
WifiStatus respondToDataPathIndicationRequestInternal(
uint16_t cmd_id, const 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<IWifiNanIfaceEventCallback>& callback);
WifiStatus enableRequest_1_5Internal(
uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_5Internal(
uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
const NanConfigRequestSupplemental& msg2);
WifiStatus getCapabilitiesRequest_1_5Internal(uint16_t cmd_id);
// 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<IWifiNanIfaceEventCallback>> getEventCallbacks_1_5();
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<IWifiNanIfaceEventCallback>
event_cb_handler_1_5_;
DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
};
} // namespace implementation
} // namespace V1_5
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_NAN_IFACE_H_

351
wifi/1.5/default/wifi_rtt_controller.cpp
View File

@@ -1,351 +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_5 {
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_4::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 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 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);
}
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 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) {
// TODO(b/31632518): remove the callback when the client is destroyed
event_callbacks_.emplace_back(callback);
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus WifiRttController::rangeRequestInternal_1_4(
uint32_t cmd_id, const std::vector<V1_4::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_4::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()) {
callback->onResults_1_4(id, hidl_results);
}
};
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_4::RttCapabilities>
WifiRttController::getCapabilitiesInternal_1_4() {
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_4::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_4::RttResponder>
WifiRttController::getResponderInfoInternal_1_4() {
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_4::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_4(
uint32_t cmd_id, const WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_4::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_5
} // namespace wifi
} // namespace hardware
} // namespace android

187
wifi/1.5/default/wifi_sta_iface.h
View File

@@ -1,187 +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.5/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_5 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
/**
* HIDL interface object used to control a STA Iface instance.
*/
class WifiStaIface : public V1_5::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> 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();
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_5
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_STA_IFACE_H_

32
wifi/1.6/Android.bp Normal file
View File

@@ -0,0 +1,32 @@
// This file is autogenerated by hidl-gen -Landroidbp.
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"],
}
hidl_interface {
name: "android.hardware.wifi@1.6",
root: "android.hardware",
srcs: [
"IWifi.hal",
],
interfaces: [
"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.hidl.base@1.0",
],
gen_java: true,
apex_available: [
"//apex_available:platform",
"com.android.wifi",
],
}

27
wifi/1.6/IWifi.hal Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 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 android.hardware.wifi@1.6;
import @1.5::IWifi;
/**
* This is the root of the HAL module and is the interface returned when
* loading an implementation of the Wi-Fi HAL. There must be at most one
* module loaded in the system.
* IWifi.getChip() must return @1.5::IWifiChip
*/
interface IWifi extends @1.5::IWifi {};

0
wifi/1.5/default/Android.bp → wifi/1.6/default/Android.bp
View File

10
wifi/1.5/default/Android.mk → wifi/1.6/default/Android.mk
View File

@@ -77,7 +77,8 @@ LOCAL_SHARED_LIBRARIES := \
android.hardware.wifi@1.2 \
android.hardware.wifi@1.3 \
android.hardware.wifi@1.4 \
android.hardware.wifi@1.5
android.hardware.wifi@1.5 \
android.hardware.wifi@1.6
LOCAL_C_INCLUDES += $(TOP)/external/libxml2/include
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
include $(BUILD_STATIC_LIBRARY)
@@ -111,7 +112,8 @@ LOCAL_SHARED_LIBRARIES := \
android.hardware.wifi@1.2 \
android.hardware.wifi@1.3 \
android.hardware.wifi@1.4 \
android.hardware.wifi@1.5
android.hardware.wifi@1.5 \
android.hardware.wifi@1.6
LOCAL_STATIC_LIBRARIES := \
android.hardware.wifi@1.0-service-lib
LOCAL_INIT_RC := android.hardware.wifi@1.0-service.rc
@@ -148,7 +150,8 @@ LOCAL_SHARED_LIBRARIES := \
android.hardware.wifi@1.2 \
android.hardware.wifi@1.3 \
android.hardware.wifi@1.4 \
android.hardware.wifi@1.5
android.hardware.wifi@1.5 \
android.hardware.wifi@1.6
LOCAL_STATIC_LIBRARIES := \
android.hardware.wifi@1.0-service-lib
LOCAL_INIT_RC := android.hardware.wifi@1.0-service-lazy.rc
@@ -185,6 +188,7 @@ LOCAL_STATIC_LIBRARIES := \
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
LOCAL_SHARED_LIBRARIES := \
libbase \

0
wifi/1.5/default/OWNERS → wifi/1.6/default/OWNERS
View File

0
wifi/1.5/default/THREADING.README → wifi/1.6/default/THREADING.README
View File

0
wifi/1.5/default/android.hardware.wifi@1.0-service-lazy.rc → wifi/1.6/default/android.hardware.wifi@1.0-service-lazy.rc
View File

1
wifi/1.5/default/android.hardware.wifi@1.0-service.rc → wifi/1.6/default/android.hardware.wifi@1.0-service.rc
View File

@@ -5,6 +5,7 @@ service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi@1.0-service
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

2
wifi/1.5/default/android.hardware.wifi@1.0-service.xml → wifi/1.6/default/android.hardware.wifi@1.0-service.xml
View File

@@ -2,7 +2,7 @@
<hal format="hidl">
<name>android.hardware.wifi</name>
<transport>hwbinder</transport>
<version>1.5</version>
<version>1.6</version>
<interface>
<name>IWifi</name>
<instance>default</instance>

25
wifi/1.5/default/hidl_callback_util.h → wifi/1.6/default/hidl_callback_util.h
View File

@@ -29,20 +29,18 @@ using on_death_cb_function = std::function<void(uint64_t)>;
// callbacks stored in HidlCallbackHandler.
template <typename CallbackType>
class HidlDeathHandler : public android::hardware::hidl_death_recipient {
public:
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 {
void serviceDied(uint64_t cookie,
const android::wp<android::hidl::base::V1_0::IBase>& /* who */) override {
cb_function_(cookie);
}
private:
private:
on_death_cb_function cb_function_;
DISALLOW_COPY_AND_ASSIGN(HidlDeathHandler);
@@ -52,18 +50,17 @@ class HidlDeathHandler : public android::hardware::hidl_death_recipient {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
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:
public:
HidlCallbackHandler()
: death_handler_(new HidlDeathHandler<CallbackType>(
std::bind(&HidlCallbackHandler::onObjectDeath, this,
std::placeholders::_1))) {}
std::bind(&HidlCallbackHandler::onObjectDeath, this, std::placeholders::_1))) {}
~HidlCallbackHandler() = default;
bool addCallback(const sp<CallbackType>& cb) {
@@ -83,9 +80,7 @@ class HidlCallbackHandler {
return true;
}
const std::set<android::sp<CallbackType>>& getCallbacks() {
return cb_set_;
}
const std::set<android::sp<CallbackType>>& getCallbacks() { return cb_set_; }
// Death notification for callbacks.
void onObjectDeath(uint64_t cookie) {
@@ -108,7 +103,7 @@ class HidlCallbackHandler {
cb_set_.clear();
}
private:
private:
std::set<sp<CallbackType>> cb_set_;
sp<HidlDeathHandler<CallbackType>> death_handler_;
@@ -117,7 +112,7 @@ class HidlCallbackHandler {
} // namespace hidl_callback_util
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

32
wifi/1.5/default/hidl_return_util.h → wifi/1.6/default/hidl_return_util.h
View File

@@ -23,7 +23,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace hidl_return_util {
using namespace android::hardware::wifi::V1_0;
@@ -40,9 +40,9 @@ using namespace android::hardware::wifi::V1_0;
*/
// 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) {
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)...));
@@ -56,9 +56,10 @@ Return<void> validateAndCall(
// 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) {
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)...));
@@ -71,10 +72,9 @@ Return<void> validateAndCallWithLock(
// 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) {
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)...);
@@ -90,12 +90,10 @@ Return<void> validateAndCall(
// Use for HIDL methods which return instance of WifiStatus and 2 return
// values.
template <typename ObjT, typename WorkFuncT, typename ReturnT1,
typename ReturnT2, typename... Args>
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) {
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)...);
@@ -113,7 +111,7 @@ Return<void> validateAndCall(
} // namespace hidl_return_util
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

1517
wifi/1.5/default/hidl_struct_util.cpp → wifi/1.6/default/hidl_struct_util.cpp
View File

File diff suppressed because it is too large Load Diff

200
wifi/1.6/default/hidl_struct_util.h Normal file
View File

@@ -0,0 +1,200 @@
/*
* 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.5/IWifiChip.h>
#include <android/hardware/wifi/1.5/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);
// 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_5::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_4ToLegacy(
const V1_4::NanEnableRequest& hidl_request1,
const V1_5::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequest_1_4ToLegacy(
const V1_4::NanConfigRequest& hidl_request1,
const V1_5::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanEnableRequest_1_5ToLegacy(
const V1_4::NanEnableRequest& hidl_request1,
const V1_5::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequest_1_5ToLegacy(
const V1_4::NanConfigRequest& hidl_request1,
const V1_5::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanPublishRequestToLegacy(const NanPublishRequest& hidl_request,
legacy_hal::NanPublishRequest* legacy_request);
bool convertHidlNanSubscribeRequestToLegacy(const NanSubscribeRequest& hidl_request,
legacy_hal::NanSubscribeRequest* legacy_request);
bool convertHidlNanTransmitFollowupRequestToLegacy(
const NanTransmitFollowupRequest& hidl_request,
legacy_hal::NanTransmitFollowupRequest* legacy_request);
bool convertHidlNanDataPathInitiatorRequestToLegacy(
const NanInitiateDataPathRequest& hidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request);
bool convertHidlNanDataPathIndicationResponseToLegacy(
const 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_5::NanCapabilities* hidl_response);
bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
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_2::NanDataPathConfirmInd* hidl_ind);
bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
V1_2::NanDataPathScheduleUpdateInd* hidl_ind);
// RTT controller conversion methods.
bool convertHidlVectorOfRttConfigToLegacy(const std::vector<V1_4::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_4::RttResponder& hidl_responder,
legacy_hal::wifi_rtt_responder* legacy_responder);
bool convertHidlWifiChannelInfoToLegacy(const WifiChannelInfo& hidl_info,
legacy_hal::wifi_channel_info* legacy_info);
bool convertLegacyRttResponderToHidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
V1_4::RttResponder* hidl_responder);
bool convertLegacyRttCapabilitiesToHidl(
const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
V1_4::RttCapabilities* hidl_capabilities);
bool convertLegacyVectorOfRttResultToHidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
std::vector<V1_4::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_5::WifiUsableChannel>* hidl_usable_channels);
bool convertLegacyPeerInfoStatsToHidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
V1_5::StaPeerInfo* hidl_peer_info_stats);
bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
V1_4::WifiRateInfo* hidl_rate);
} // namespace hidl_struct_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_STRUCT_UTIL_H_

4
wifi/1.5/default/hidl_sync_util.cpp → wifi/1.6/default/hidl_sync_util.cpp
View File

@@ -23,7 +23,7 @@ std::recursive_mutex g_mutex;
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace hidl_sync_util {
@@ -33,7 +33,7 @@ std::unique_lock<std::recursive_mutex> acquireGlobalLock() {
} // namespace hidl_sync_util
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

4
wifi/1.5/default/hidl_sync_util.h → wifi/1.6/default/hidl_sync_util.h
View File

@@ -24,13 +24,13 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace hidl_sync_util {
std::unique_lock<std::recursive_mutex> acquireGlobalLock();
} // namespace hidl_sync_util
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

7
wifi/1.5/default/ringbuffer.cpp → wifi/1.6/default/ringbuffer.cpp
View File

@@ -21,7 +21,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
Ringbuffer::Ringbuffer(size_t maxSize) : size_(0), maxSize_(maxSize) {}
@@ -31,8 +31,7 @@ void Ringbuffer::append(const std::vector<uint8_t>& input) {
return;
}
if (input.size() > maxSize_) {
LOG(INFO) << "Oversized message of " << input.size()
<< " bytes is dropped";
LOG(INFO) << "Oversized message of " << input.size() << " bytes is dropped";
return;
}
data_.push_back(input);
@@ -53,7 +52,7 @@ void Ringbuffer::clear() {
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

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

@@ -23,14 +23,14 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
/**
* Ringbuffer object used to store debug data.
*/
class Ringbuffer {
public:
public:
explicit Ringbuffer(size_t maxSize);
// Appends the data buffer and deletes from the front until buffer is
@@ -39,14 +39,14 @@ class Ringbuffer {
const std::list<std::vector<uint8_t>>& getData() const;
void clear();
private:
private:
std::list<std::vector<uint8_t>> data_;
size_t size_;
size_t maxSize_;
};
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

34
wifi/1.5/default/service.cpp → wifi/1.6/default/service.cpp
View File

@@ -30,13 +30,10 @@
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::LazyServiceRegistrar;
using android::hardware::wifi::V1_5::implementation::feature_flags::
WifiFeatureFlags;
using android::hardware::wifi::V1_5::implementation::legacy_hal::WifiLegacyHal;
using android::hardware::wifi::V1_5::implementation::legacy_hal::
WifiLegacyHalFactory;
using android::hardware::wifi::V1_5::implementation::mode_controller::
WifiModeController;
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;
@@ -46,30 +43,25 @@ const bool kLazyService = false;
int main(int /*argc*/, char** argv) {
signal(SIGPIPE, SIG_IGN);
android::base::InitLogging(
argv, android::base::LogdLogger(android::base::SYSTEM));
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);
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_5::IWifi> service =
new android::hardware::wifi::V1_5::implementation::Wifi(
iface_tool, legacy_hal_factory,
std::make_shared<WifiModeController>(),
std::make_shared<WifiFeatureFlags>());
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";
<< "Failed to register wifi HAL";
} else {
CHECK_EQ(service->registerAsService(), android::NO_ERROR)
<< "Failed to register wifi HAL";
CHECK_EQ(service->registerAsService(), android::NO_ERROR) << "Failed to register wifi HAL";
}
joinRpcThreadpool();

215
wifi/1.5/default/tests/hidl_struct_util_unit_tests.cpp → wifi/1.6/default/tests/hidl_struct_util_unit_tests.cpp
View File

@@ -34,7 +34,7 @@ constexpr char kIfaceName2[] = "wlan1";
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using ::android::hardware::wifi::V1_0::WifiChannelWidthInMhz;
@@ -44,21 +44,17 @@ class HidlStructUtilTest : public Test {};
TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithOneMac) {
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 | legacy_hal::WLAN_MAC_2_4_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1,
.channel = kIfaceChannel1};
legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2,
.channel = kIfaceChannel2};
.wlan_mac_id = kMacId1,
.mac_band = legacy_hal::WLAN_MAC_5_0_BAND | legacy_hal::WLAN_MAC_2_4_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1, .channel = kIfaceChannel1};
legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2, .channel = kIfaceChannel2};
legacy_mac_info1.iface_infos.push_back(legacy_iface_info1);
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<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
&hidl_radio_mode_infos));
ASSERT_EQ(1u, hidl_radio_mode_infos.size());
auto hidl_radio_mode_info1 = hidl_radio_mode_infos[0];
@@ -67,65 +63,56 @@ TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithOneMac) {
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);
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);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
}
TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithTwoMac) {
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};
legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1,
.channel = kIfaceChannel1};
legacy_hal::WifiMacInfo legacy_mac_info2 = {
.wlan_mac_id = kMacId2, .mac_band = legacy_hal::WLAN_MAC_2_4_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2,
.channel = kIfaceChannel2};
legacy_hal::WifiMacInfo legacy_mac_info1 = {.wlan_mac_id = kMacId1,
.mac_band = legacy_hal::WLAN_MAC_5_0_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1, .channel = kIfaceChannel1};
legacy_hal::WifiMacInfo legacy_mac_info2 = {.wlan_mac_id = kMacId2,
.mac_band = legacy_hal::WLAN_MAC_2_4_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2, .channel = kIfaceChannel2};
legacy_mac_info1.iface_infos.push_back(legacy_iface_info1);
legacy_mac_infos.push_back(legacy_mac_info1);
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<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
&hidl_radio_mode_infos));
ASSERT_EQ(2u, hidl_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;
});
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;
});
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);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info1.channel), hidl_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;
});
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;
});
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);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
}
TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
@@ -143,8 +130,7 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples =
rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu = rand();
@@ -153,8 +139,7 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples =
rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu = rand();
@@ -163,8 +148,7 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples =
rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu = rand();
@@ -173,8 +157,7 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples =
rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples = rand();
legacy_stats.iface.info.time_slicing_duty_cycle_percent = rand();
legacy_stats.iface.num_peers = 1;
@@ -195,14 +178,14 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
}
legacy_hal::wifi_channel_stat channel_stat1 = {
.channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 2437, 2437, 0},
.on_time = 0x1111,
.cca_busy_time = 0x55,
.channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 2437, 2437, 0},
.on_time = 0x1111,
.cca_busy_time = 0x55,
};
legacy_hal::wifi_channel_stat channel_stat2 = {
.channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 5180, 5180, 0},
.on_time = 0x2222,
.cca_busy_time = 0x66,
.channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 5180, 5180, 0},
.on_time = 0x2222,
.cca_busy_time = 0x66,
};
radio.channel_stats.push_back(channel_stat1);
radio.channel_stats.push_back(channel_stat2);
@@ -212,30 +195,29 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
peer.peer_info.bssload.sta_count = rand();
peer.peer_info.bssload.chan_util = rand();
wifi_rate_stat rate_stat1 = {
.rate = {3, 1, 2, 5, 0, 0},
.tx_mpdu = 0,
.rx_mpdu = 1,
.mpdu_lost = 2,
.retries = 3,
.retries_short = 4,
.retries_long = 5,
.rate = {3, 1, 2, 5, 0, 0},
.tx_mpdu = 0,
.rx_mpdu = 1,
.mpdu_lost = 2,
.retries = 3,
.retries_short = 4,
.retries_long = 5,
};
wifi_rate_stat rate_stat2 = {
.rate = {2, 2, 1, 6, 0, 1},
.tx_mpdu = 6,
.rx_mpdu = 7,
.mpdu_lost = 8,
.retries = 9,
.retries_short = 10,
.retries_long = 11,
.rate = {2, 2, 1, 6, 0, 1},
.tx_mpdu = 6,
.rx_mpdu = 7,
.mpdu_lost = 8,
.retries = 9,
.retries_short = 10,
.retries_long = 11,
};
peer.rate_stats.push_back(rate_stat1);
peer.rate_stats.push_back(rate_stat2);
}
V1_5::StaLinkLayerStats converted{};
hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats,
&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);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu,
@@ -252,9 +234,8 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
converted.iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg,
converted.iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples,
converted.iface.wmeBeContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples,
converted.iface.wmeBeContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu,
converted.iface.V1_0.wmeBkPktStats.rxMpdu);
@@ -270,9 +251,8 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
converted.iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg,
converted.iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples,
converted.iface.wmeBkContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples,
converted.iface.wmeBkContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu,
converted.iface.V1_0.wmeViPktStats.rxMpdu);
@@ -288,9 +268,8 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
converted.iface.wmeViContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg,
converted.iface.wmeViContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples,
converted.iface.wmeViContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples,
converted.iface.wmeViContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu,
converted.iface.V1_0.wmeVoPktStats.rxMpdu);
@@ -306,29 +285,23 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
converted.iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg,
converted.iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples,
converted.iface.wmeVoContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples,
converted.iface.wmeVoContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.info.time_slicing_duty_cycle_percent,
converted.iface.timeSliceDutyCycleInPercent);
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_3.V1_0.onTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.tx_time,
converted.radios[i].V1_3.V1_0.txTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.rx_time,
converted.radios[i].V1_3.V1_0.rxTimeInMs);
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_3.V1_0.onTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.tx_time, converted.radios[i].V1_3.V1_0.txTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.rx_time, converted.radios[i].V1_3.V1_0.rxTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_scan,
converted.radios[i].V1_3.V1_0.onTimeInMsForScan);
EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels.size(),
converted.radios[i].V1_3.V1_0.txTimeInMsPerLevel.size());
for (size_t j = 0; j < legacy_stats.radios[i].tx_time_per_levels.size();
j++) {
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_3.V1_0.txTimeInMsPerLevel[j]);
}
@@ -344,20 +317,16 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
converted.radios[i].V1_3.onTimeInMsForHs20Scan);
EXPECT_EQ(legacy_stats.radios[i].channel_stats.size(),
converted.radios[i].V1_3.channelStats.size());
for (size_t k = 0; k < legacy_stats.radios[i].channel_stats.size();
k++) {
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].V1_3.channelStats[k].channel.width);
EXPECT_EQ(
WifiChannelInMhz(legacy_channel_st.channel.center_freq),
converted.radios[i].V1_3.channelStats[k].channel.centerFreq);
EXPECT_EQ(
WifiChannelInMhz(legacy_channel_st.channel.center_freq0),
converted.radios[i].V1_3.channelStats[k].channel.centerFreq0);
EXPECT_EQ(
WifiChannelInMhz(legacy_channel_st.channel.center_freq1),
converted.radios[i].V1_3.channelStats[k].channel.centerFreq1);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq),
converted.radios[i].V1_3.channelStats[k].channel.centerFreq);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq0),
converted.radios[i].V1_3.channelStats[k].channel.centerFreq0);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq1),
converted.radios[i].V1_3.channelStats[k].channel.centerFreq1);
EXPECT_EQ(legacy_channel_st.cca_busy_time,
converted.radios[i].V1_3.channelStats[k].ccaBusyTimeInMs);
EXPECT_EQ(legacy_channel_st.on_time,
@@ -373,18 +342,13 @@ TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
converted.iface.peers[i].chanUtil);
for (size_t j = 0; j < legacy_stats.peers[i].rate_stats.size(); j++) {
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.preamble,
(uint32_t)converted.iface.peers[i]
.rateStats[j]
.rateInfo.preamble);
EXPECT_EQ(
legacy_stats.peers[i].rate_stats[j].rate.nss,
(uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.nss);
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.preamble);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.nss,
(uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.nss);
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);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].tx_mpdu,
converted.iface.peers[i].rateStats[j].txMpdu);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rx_mpdu,
@@ -402,23 +366,20 @@ TEST_F(HidlStructUtilTest, CanConvertLegacyFeaturesToHidl) {
uint32_t hidle_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;
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));
legacy_feature_set, legacy_logger_feature_set, &hidle_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,
HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS |
HidlChipCaps::DEBUG_ERROR_ALERTS | HidlChipCaps::D2D_RTT |
HidlChipCaps::SET_LATENCY_MODE | HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP,
hidle_caps);
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

0
wifi/1.5/default/tests/main.cpp → wifi/1.6/default/tests/main.cpp
View File

0
wifi/1.5/default/tests/mock_interface_tool.cpp → wifi/1.6/default/tests/mock_interface_tool.cpp
View File

8
wifi/1.5/default/tests/mock_interface_tool.h → wifi/1.6/default/tests/mock_interface_tool.h
View File

@@ -24,17 +24,15 @@ namespace android {
namespace wifi_system {
class MockInterfaceTool : public InterfaceTool {
public:
public:
MockInterfaceTool();
MOCK_METHOD1(GetUpState, bool(const char* if_name));
MOCK_METHOD2(SetUpState, bool(const char* if_name, bool request_up));
MOCK_METHOD1(SetWifiUpState, bool(bool request_up));
MOCK_METHOD2(SetMacAddress,
bool(const char* if_name,
const std::array<uint8_t, ETH_ALEN>& address));
MOCK_METHOD1(GetFactoryMacAddress,
std::array<uint8_t, ETH_ALEN>(const char* if_name));
bool(const char* if_name, const std::array<uint8_t, ETH_ALEN>& address));
MOCK_METHOD1(GetFactoryMacAddress, std::array<uint8_t, ETH_ALEN>(const char* if_name));
}; // class MockInterfaceTool

4
wifi/1.5/default/tests/mock_wifi_feature_flags.cpp → wifi/1.6/default/tests/mock_wifi_feature_flags.cpp
View File

@@ -21,7 +21,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
@@ -29,7 +29,7 @@ MockWifiFeatureFlags::MockWifiFeatureFlags() {}
} // namespace feature_flags
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

9
wifi/1.5/default/tests/mock_wifi_feature_flags.h → wifi/1.6/default/tests/mock_wifi_feature_flags.h
View File

@@ -25,22 +25,21 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
class MockWifiFeatureFlags : public WifiFeatureFlags {
public:
public:
MockWifiFeatureFlags();
MOCK_METHOD1(getChipModes,
std::vector<V1_0::IWifiChip::ChipMode>(bool is_primary));
MOCK_METHOD1(getChipModes, std::vector<V1_0::IWifiChip::ChipMode>(bool is_primary));
MOCK_METHOD0(isApMacRandomizationDisabled, bool());
};
} // namespace feature_flags
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

9
wifi/1.5/default/tests/mock_wifi_iface_util.cpp → wifi/1.6/default/tests/mock_wifi_iface_util.cpp
View File

@@ -24,17 +24,16 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
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<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_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

20
wifi/1.5/default/tests/mock_wifi_iface_util.h → wifi/1.6/default/tests/mock_wifi_iface_util.h
View File

@@ -24,29 +24,25 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace iface_util {
class MockWifiIfaceUtil : public WifiIfaceUtil {
public:
MockWifiIfaceUtil(
const std::weak_ptr<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>&));
public:
MockWifiIfaceUtil(const std::weak_ptr<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&, 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_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

9
wifi/1.5/default/tests/mock_wifi_legacy_hal.cpp → wifi/1.6/default/tests/mock_wifi_legacy_hal.cpp
View File

@@ -24,17 +24,16 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
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<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_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

41
wifi/1.5/default/tests/mock_wifi_legacy_hal.h → wifi/1.6/default/tests/mock_wifi_legacy_hal.h
View File

@@ -24,49 +24,42 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
class MockWifiLegacyHal : public WifiLegacyHal {
public:
MockWifiLegacyHal(
const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary);
public:
MockWifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary);
MOCK_METHOD0(initialize, wifi_error());
MOCK_METHOD0(start, wifi_error());
MOCK_METHOD2(stop, wifi_error(std::unique_lock<std::recursive_mutex>*,
const std::function<void()>&));
MOCK_METHOD2(stop,
wifi_error(std::unique_lock<std::recursive_mutex>*, const std::function<void()>&));
MOCK_METHOD2(setDfsFlag, wifi_error(const std::string&, bool));
MOCK_METHOD2(registerRadioModeChangeCallbackHandler,
wifi_error(const std::string&,
const on_radio_mode_change_callback&));
MOCK_METHOD1(getFirmwareVersion, std::pair<wifi_error, std::string>(
const std::string& iface_name));
MOCK_METHOD1(getDriverVersion, std::pair<wifi_error, std::string>(
const std::string& iface_name));
wifi_error(const std::string&, const on_radio_mode_change_callback&));
MOCK_METHOD1(getFirmwareVersion,
std::pair<wifi_error, std::string>(const std::string& iface_name));
MOCK_METHOD1(getDriverVersion,
std::pair<wifi_error, std::string>(const std::string& iface_name));
MOCK_METHOD2(selectTxPowerScenario,
wifi_error(const std::string& iface_name,
wifi_power_scenario scenario));
MOCK_METHOD1(resetTxPowerScenario,
wifi_error(const std::string& iface_name));
wifi_error(const std::string& iface_name, wifi_power_scenario scenario));
MOCK_METHOD1(resetTxPowerScenario, wifi_error(const std::string& iface_name));
MOCK_METHOD2(nanRegisterCallbackHandlers,
wifi_error(const std::string&, const NanCallbackHandlers&));
MOCK_METHOD2(nanDisableRequest,
wifi_error(const std::string&, transaction_id));
MOCK_METHOD2(nanDisableRequest, wifi_error(const std::string&, transaction_id));
MOCK_METHOD3(nanDataInterfaceDelete,
wifi_error(const std::string&, transaction_id,
const std::string&));
wifi_error(const std::string&, transaction_id, const std::string&));
MOCK_METHOD2(createVirtualInterface,
wifi_error(const std::string& ifname,
wifi_interface_type iftype));
wifi_error(const std::string& ifname, wifi_interface_type iftype));
MOCK_METHOD1(deleteVirtualInterface, wifi_error(const std::string& ifname));
MOCK_METHOD0(waitForDriverReady, wifi_error());
};
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

4
wifi/1.5/default/tests/mock_wifi_mode_controller.cpp → wifi/1.6/default/tests/mock_wifi_mode_controller.cpp
View File

@@ -24,14 +24,14 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
MockWifiModeController::MockWifiModeController() : WifiModeController() {}
} // namespace mode_controller
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

6
wifi/1.5/default/tests/mock_wifi_mode_controller.h → wifi/1.6/default/tests/mock_wifi_mode_controller.h
View File

@@ -24,12 +24,12 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
class MockWifiModeController : public WifiModeController {
public:
public:
MockWifiModeController();
MOCK_METHOD0(initialize, bool());
MOCK_METHOD1(changeFirmwareMode, bool(IfaceType));
@@ -38,7 +38,7 @@ class MockWifiModeController : public WifiModeController {
};
} // namespace mode_controller
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

6
wifi/1.5/default/tests/ringbuffer_unit_tests.cpp → wifi/1.6/default/tests/ringbuffer_unit_tests.cpp
View File

@@ -24,11 +24,11 @@ using testing::Test;
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
class RingbufferTest : public Test {
public:
public:
const uint32_t maxBufferSize_ = 10;
Ringbuffer buffer_{maxBufferSize_};
};
@@ -91,7 +91,7 @@ TEST_F(RingbufferTest, OversizedAppendDoesNotDropExistingData) {
EXPECT_EQ(input, buffer_.getData().front());
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

0
wifi/1.5/default/tests/runtests.sh → wifi/1.6/default/tests/runtests.sh
View File

349
wifi/1.5/default/tests/wifi_chip_unit_tests.cpp → wifi/1.6/default/tests/wifi_chip_unit_tests.cpp
View File

@@ -41,11 +41,11 @@ constexpr ChipId kFakeChipId = 5;
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
class WifiChipTest : public Test {
protected:
protected:
void setupV1IfaceCombination() {
// clang-format off
const hidl_vec<V1_0::IWifiChip::ChipIfaceCombination> combinationsSta = {
@@ -59,8 +59,7 @@ class WifiChipTest : public Test {
{feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true))
.WillRepeatedly(testing::Return(modes));
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV1_AwareIfaceCombination() {
@@ -76,8 +75,7 @@ class WifiChipTest : public Test {
{feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true))
.WillRepeatedly(testing::Return(modes));
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV1_AwareDisabledApIfaceCombination() {
@@ -89,8 +87,7 @@ class WifiChipTest : public Test {
{feature_flags::chip_mode_ids::kV1Sta, combinationsSta}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true))
.WillRepeatedly(testing::Return(modes));
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV2_AwareIfaceCombination() {
@@ -103,8 +100,7 @@ class WifiChipTest : public Test {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true))
.WillRepeatedly(testing::Return(modes));
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV2_AwareDisabledApIfaceCombination() {
@@ -116,8 +112,7 @@ class WifiChipTest : public Test {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true))
.WillRepeatedly(testing::Return(modes));
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setup_MultiIfaceCombination() {
@@ -129,39 +124,35 @@ class WifiChipTest : public Test {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true))
.WillRepeatedly(testing::Return(modes));
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void assertNumberOfModes(uint32_t num_modes) {
chip_->getAvailableModes(
[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());
});
chip_->getAvailableModes([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());
});
}
void findModeAndConfigureForIfaceType(const IfaceType& type) {
// This should be aligned with kInvalidModeId in wifi_chip.cpp.
ChipModeId mode_id = UINT32_MAX;
chip_->getAvailableModes(
[&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;
}
chip_->getAvailableModes([&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;
}
}
}
});
}
});
ASSERT_NE(UINT32_MAX, mode_id);
chip_->configureChip(mode_id, [](const WifiStatus& status) {
@@ -174,58 +165,53 @@ class WifiChipTest : public Test {
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();
});
}
});
[&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();
});
}
});
[&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();
});
}
});
} 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();
});
}
});
[&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();
});
}
});
} 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();
});
}
});
[&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();
});
}
});
}
return iface_name;
}
@@ -253,13 +239,12 @@ class WifiChipTest : public Test {
bool createRttController() {
bool success = false;
chip_->createRttController_1_4(
NULL, [&success](const WifiStatus& status,
const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
success = true;
}
});
NULL, [&success](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
success = true;
}
});
return success;
}
@@ -269,27 +254,25 @@ class WifiChipTest : public Test {
ChipId 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>};
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<mode_controller::MockWifiModeController>>
mode_controller_{new NiceMock<mode_controller::MockWifiModeController>};
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>> mode_controller_{
new NiceMock<mode_controller::MockWifiModeController>};
std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
std::shared_ptr<NiceMock<feature_flags::MockWifiFeatureFlags>>
feature_flags_{new NiceMock<feature_flags::MockWifiFeatureFlags>};
new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
std::shared_ptr<NiceMock<feature_flags::MockWifiFeatureFlags>> feature_flags_{
new NiceMock<feature_flags::MockWifiFeatureFlags>};
public:
public:
void SetUp() override {
chip_ =
new WifiChip(chip_id_, true, legacy_hal_, mode_controller_,
iface_util_, feature_flags_, subsystemRestartHandler);
chip_ = new WifiChip(chip_id_, true, legacy_hal_, mode_controller_, iface_util_,
feature_flags_, subsystemRestartHandler);
EXPECT_CALL(*mode_controller_, changeFirmwareMode(testing::_))
.WillRepeatedly(testing::Return(true));
.WillRepeatedly(testing::Return(true));
EXPECT_CALL(*legacy_hal_, start())
.WillRepeatedly(testing::Return(legacy_hal::WIFI_SUCCESS));
.WillRepeatedly(testing::Return(legacy_hal::WIFI_SUCCESS));
}
void TearDown() override {
@@ -305,7 +288,7 @@ class WifiChipTest : public Test {
// Mode 1 - STA + P2P
// Mode 2 - AP
class WifiChipV1IfaceCombinationTest : public WifiChipTest {
public:
public:
void SetUp() override {
setupV1IfaceCombination();
WifiChipTest::SetUp();
@@ -364,7 +347,7 @@ TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
// Mode 1 - STA + P2P/NAN
// Mode 2 - AP
class WifiChipV1_AwareIfaceCombinationTest : public WifiChipTest {
public:
public:
void SetUp() override {
setupV1_AwareIfaceCombination();
WifiChipTest::SetUp();
@@ -393,30 +376,26 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
ASSERT_TRUE(createIface(IfaceType::AP).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest,
StaMode_CreateStaP2p_ShouldSucceed) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2p_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest,
StaMode_CreateStaNan_ShouldSucceed) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest,
StaMode_CreateStaP2PNan_ShouldFail) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2PNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest,
StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
@@ -428,8 +407,7 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest,
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest,
StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
@@ -488,31 +466,27 @@ TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
.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);
});
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
findModeAndConfigureForIfaceType(IfaceType::AP);
ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
.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);
});
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
////////// V2 + Aware Iface Combinations ////////////
// Mode 1 - STA + STA/AP
// - STA + P2P/NAN
class WifiChipV2_AwareIfaceCombinationTest : public WifiChipTest {
public:
public:
void SetUp() override {
setupV2_AwareIfaceCombination();
WifiChipTest::SetUp();
@@ -559,8 +533,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApSta_ShouldSucceed) {
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
CreateSta_AfterStaApRemove_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_AfterStaApRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
const auto sta_iface_name = createIface(IfaceType::STA);
ASSERT_FALSE(sta_iface_name.empty());
@@ -594,8 +567,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2PNan_ShouldFail) {
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
CreateStaNan_AfterP2pRemove_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
@@ -607,8 +579,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest,
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
CreateStaP2p_AfterNanRemove_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
@@ -632,8 +603,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApP2p_ShouldFail) {
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
@@ -645,8 +615,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest,
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
@@ -658,8 +627,7 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest,
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
CreateStaAp_EnsureDifferentIfaceNames) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_EnsureDifferentIfaceNames) {
findModeAndConfigureForIfaceType(IfaceType::AP);
const auto sta_iface_name = createIface(IfaceType::STA);
const auto ap_iface_name = createIface(IfaceType::AP);
@@ -690,28 +658,23 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
.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);
});
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
findModeAndConfigureForIfaceType(IfaceType::AP);
ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan1", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
.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);
});
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
InvalidateAndRemoveNanOnStaRemove) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveNanOnStaRemove) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
@@ -719,64 +682,55 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest,
ASSERT_EQ(createIface(IfaceType::NAN), "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");
});
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;
});
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;
});
// Remove the STA iface.
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);
});
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);
});
nan_iface->getName([](const WifiStatus& status, const std::string& /* iface_name */) {
ASSERT_EQ(WifiStatusCode::ERROR_WIFI_IFACE_INVALID, status.code);
});
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest,
InvalidateAndRemoveRttControllerOnStaRemove) {
TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveRttControllerOnStaRemove) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
// Create RTT controller
sp<IWifiRttController> rtt_controller;
chip_->createRttController_1_4(
NULL, [&rtt_controller](const WifiStatus& status,
const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
rtt_controller = rtt;
}
});
NULL, [&rtt_controller](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
rtt_controller = rtt;
}
});
// 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);
});
rtt_controller->getBoundIface([](const WifiStatus& status, const sp<IWifiIface>& /* iface */) {
ASSERT_EQ(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, status.code);
});
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithSharedNanIface) {
@@ -792,28 +746,24 @@ TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithDedicatedNanIface) {
property_set("wifi.aware.interface", "aware0");
findModeAndConfigureForIfaceType(IfaceType::STA);
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));
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");
EXPECT_CALL(*iface_util_, setUpState("aware0", false))
.WillOnce(testing::Return(true));
EXPECT_CALL(*iface_util_, setUpState("aware0", false)).WillOnce(testing::Return(true));
removeIface(IfaceType::NAN, "aware0");
}
////////// V1 Iface Combinations when AP creation is disabled //////////
class WifiChipV1_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
public:
public:
void SetUp() override {
setupV1_AwareDisabledApIfaceCombination();
WifiChipTest::SetUp();
}
};
TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest,
StaMode_CreateSta_ShouldSucceed) {
TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_TRUE(createIface(IfaceType::AP).empty());
@@ -821,15 +771,14 @@ TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest,
////////// V2 Iface Combinations when AP creation is disabled //////////
class WifiChipV2_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
public:
public:
void SetUp() override {
setupV2_AwareDisabledApIfaceCombination();
WifiChipTest::SetUp();
}
};
TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest,
CreateSta_ShouldSucceed) {
TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest, CreateSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_TRUE(createIface(IfaceType::AP).empty());
@@ -837,7 +786,7 @@ TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest,
////////// Hypothetical Iface Combination with multiple ifaces //////////
class WifiChip_MultiIfaceTest : public WifiChipTest {
public:
public:
void SetUp() override {
setup_MultiIfaceCombination();
WifiChipTest::SetUp();
@@ -899,7 +848,7 @@ TEST_F(WifiChip_MultiIfaceTest, CreateApStartsWithIdx1) {
ASSERT_EQ(createIface(IfaceType::STA), "wlan3");
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

25
wifi/1.5/default/tests/wifi_iface_util_unit_tests.cpp → wifi/1.6/default/tests/wifi_iface_util_unit_tests.cpp
View File

@@ -32,8 +32,7 @@ constexpr uint8_t kValidUnicastLocallyAssignedMacAddressMask = 0x02;
constexpr uint8_t kMacAddress[] = {0x02, 0x12, 0x45, 0x56, 0xab, 0xcc};
constexpr char kIfaceName[] = "test-wlan0";
bool isValidUnicastLocallyAssignedMacAddress(
const std::array<uint8_t, 6>& mac_address) {
bool isValidUnicastLocallyAssignedMacAddress(const std::array<uint8_t, 6>& mac_address) {
uint8_t first_byte = mac_address[0];
return (first_byte & 0x3) == kValidUnicastLocallyAssignedMacAddressMask;
}
@@ -42,17 +41,16 @@ bool isValidUnicastLocallyAssignedMacAddress(
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace iface_util {
class WifiIfaceUtilTest : public Test {
protected:
protected:
std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<wifi_system::MockInterfaceTool>};
new NiceMock<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)};
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
WifiIfaceUtil* iface_util_ = new WifiIfaceUtil(iface_tool_, legacy_hal_);
};
@@ -67,20 +65,17 @@ TEST_F(WifiIfaceUtilTest, GetOrCreateRandomMacAddress) {
TEST_F(WifiIfaceUtilTest, IfaceEventHandlers_SetMacAddress) {
std::array<uint8_t, 6> mac_address = {};
std::copy(std::begin(kMacAddress), std::end(kMacAddress),
std::begin(mac_address));
std::copy(std::begin(kMacAddress), std::end(kMacAddress), std::begin(mac_address));
EXPECT_CALL(*iface_tool_, SetMacAddress(testing::_, testing::_))
.WillRepeatedly(testing::Return(true));
.WillRepeatedly(testing::Return(true));
EXPECT_CALL(*iface_tool_, SetUpState(testing::_, testing::_))
.WillRepeatedly(testing::Return(true));
.WillRepeatedly(testing::Return(true));
// Register for iface state toggle events.
bool callback_invoked = false;
iface_util::IfaceEventHandlers event_handlers = {};
event_handlers.on_state_toggle_off_on =
[&callback_invoked](const std::string& /* iface_name */) {
callback_invoked = true;
};
[&callback_invoked](const std::string& /* iface_name */) { callback_invoked = true; };
iface_util_->registerIfaceEventHandlers(kIfaceName, event_handlers);
// Invoke setMacAddress and ensure that the cb is invoked.
ASSERT_TRUE(iface_util_->setMacAddress(kIfaceName, mac_address));
@@ -95,7 +90,7 @@ TEST_F(WifiIfaceUtilTest, IfaceEventHandlers_SetMacAddress) {
}
} // namespace iface_util
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

132
wifi/1.6/default/tests/wifi_nan_iface_unit_tests.cpp Normal file
View File

@@ -0,0 +1,132 @@
/*
* 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 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 NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathScheduleUpdate, 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

108
wifi/1.5/default/wifi.cpp → wifi/1.6/default/wifi.cpp
View File

@@ -28,16 +28,15 @@ static constexpr android::hardware::wifi::V1_0::ChipId kPrimaryChipId = 0;
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
using hidl_return_util::validateAndCallWithLock;
Wifi::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)
Wifi::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)
: iface_tool_(iface_tool),
legacy_hal_factory_(legacy_hal_factory),
mode_controller_(mode_controller),
@@ -49,46 +48,44 @@ bool Wifi::isValid() {
return true;
}
Return<void> Wifi::registerEventCallback(
const sp<V1_0::IWifiEventCallback>& event_callback,
registerEventCallback_cb hidl_status_cb) {
Return<void> Wifi::registerEventCallback(const sp<V1_0::IWifiEventCallback>& event_callback,
registerEventCallback_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::registerEventCallbackInternal, hidl_status_cb,
&Wifi::registerEventCallbackInternal, hidl_status_cb, event_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);
}
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);
Return<bool> Wifi::isStarted() {
return run_state_ != RunState::STOPPED;
}
Return<bool> Wifi::isStarted() { return run_state_ != RunState::STOPPED; }
Return<void> Wifi::start(start_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::startInternal, hidl_status_cb);
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::startInternal,
hidl_status_cb);
}
Return<void> Wifi::stop(stop_cb hidl_status_cb) {
return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::stopInternal, hidl_status_cb);
return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::stopInternal,
hidl_status_cb);
}
Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::getChipIdsInternal, hidl_status_cb);
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipIdsInternal,
hidl_status_cb);
}
Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::getChipInternal, hidl_status_cb, chip_id);
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipInternal,
hidl_status_cb, chip_id);
}
Return<void> Wifi::debug(const hidl_handle& handle,
const hidl_vec<hidl_string>&) {
Return<void> Wifi::debug(const hidl_handle& handle, const hidl_vec<hidl_string>&) {
LOG(INFO) << "-----------Debug is called----------------";
if (chips_.size() == 0) {
return Void();
@@ -103,13 +100,13 @@ Return<void> Wifi::debug(const hidl_handle& handle,
}
WifiStatus Wifi::registerEventCallbackInternal(
const sp<V1_0::IWifiEventCallback>& event_callback __unused) {
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) {
const sp<V1_5::IWifiEventCallback>& event_callback) {
if (!event_cb_handler_.addCallback(event_callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
@@ -120,36 +117,32 @@ WifiStatus Wifi::startInternal() {
if (run_state_ == RunState::STARTED) {
return createWifiStatus(WifiStatusCode::SUCCESS);
} else if (run_state_ == RunState::STOPPING) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
"HAL is stopping");
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
}
WifiStatus wifi_status = initializeModeControllerAndLegacyHal();
if (wifi_status.code == WifiStatusCode::SUCCESS) {
// 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);
for (const auto& callback : event_cb_handler_.getCallbacks()) {
LOG(INFO) << "Attempting to invoke onSubsystemRestart "
const auto& on_subsystem_restart_callback = [this](const std::string& error) {
WifiStatus 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()) {
LOG(ERROR) << "Failed to invoke onSubsystemRestart callback";
} else {
LOG(INFO) << "Succeeded to invoke onSubsystemRestart "
"callback";
if (!callback->onSubsystemRestart(wifi_status).isOk()) {
LOG(ERROR)
<< "Failed to invoke onSubsystemRestart callback";
} else {
LOG(INFO) << "Succeeded to invoke onSubsystemRestart "
"callback";
}
}
};
}
};
// Create the chip instance once the HAL is started.
android::hardware::wifi::V1_0::ChipId 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));
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));
chipId++;
}
run_state_ = RunState::STARTED;
@@ -173,12 +166,11 @@ WifiStatus Wifi::startInternal() {
}
WifiStatus Wifi::stopInternal(
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
if (run_state_ == RunState::STOPPED) {
return createWifiStatus(WifiStatusCode::SUCCESS);
} else if (run_state_ == RunState::STOPPING) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE,
"HAL is stopping");
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
}
// Clear the chip object and its child objects since the HAL is now
// stopped.
@@ -220,8 +212,7 @@ std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
}
std::pair<WifiStatus, sp<V1_4::IWifiChip>> Wifi::getChipInternal(
ChipId chip_id) {
std::pair<WifiStatus, sp<V1_4::IWifiChip>> Wifi::getChipInternal(ChipId chip_id) {
for (auto& chip : chips_) {
ChipId cand_id = getChipIdFromWifiChip(chip);
if ((cand_id != UINT32_MAX) && (cand_id == chip_id))
@@ -238,8 +229,7 @@ WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
}
legacy_hals_ = legacy_hal_factory_->getHals();
if (legacy_hals_.empty())
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
if (legacy_hals_.empty()) return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
int index = 0; // for failure log
for (auto& hal : legacy_hals_) {
legacy_hal::wifi_error legacy_status = hal->initialize();
@@ -258,7 +248,7 @@ WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
}
WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
legacy_hal::wifi_error legacy_status = legacy_hal::WIFI_SUCCESS;
int index = 0;
@@ -298,7 +288,7 @@ ChipId Wifi::getChipIdFromWifiChip(sp<WifiChip>& chip) {
return chip_id;
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

40
wifi/1.5/default/wifi.h → wifi/1.6/default/wifi.h
View File

@@ -21,7 +21,7 @@
// 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.5/IWifi.h>
#include <android/hardware/wifi/1.6/IWifi.h>
#include <android-base/macros.h>
#include <utils/Looper.h>
@@ -37,46 +37,41 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
/**
* Root HIDL interface object used to control the Wifi HAL.
*/
class Wifi : public V1_5::IWifi {
public:
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<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<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;
Return<void> debug(const hidl_handle& handle, const hidl_vec<hidl_string>& options) override;
private:
private:
enum class RunState { STOPPED, STARTED, STOPPING };
// Corresponding worker functions for the HIDL methods.
WifiStatus registerEventCallbackInternal(
const sp<V1_0::IWifiEventCallback>& event_callback __unused);
const sp<V1_0::IWifiEventCallback>& event_callback __unused);
WifiStatus registerEventCallbackInternal_1_5(
const sp<V1_5::IWifiEventCallback>& event_callback);
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();
@@ -84,7 +79,7 @@ class Wifi : public V1_5::IWifi {
WifiStatus initializeModeControllerAndLegacyHal();
WifiStatus stopLegacyHalAndDeinitializeModeController(
std::unique_lock<std::recursive_mutex>* lock);
std::unique_lock<std::recursive_mutex>* lock);
ChipId getChipIdFromWifiChip(sp<WifiChip>& chip);
// Instance is created in this root level |IWifi| HIDL interface object
@@ -96,14 +91,13 @@ class Wifi : public V1_5::IWifi {
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_;
hidl_callback_util::HidlCallbackHandler<V1_5::IWifiEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(Wifi);
};
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

88
wifi/1.5/default/wifi_ap_iface.cpp → wifi/1.6/default/wifi_ap_iface.cpp
View File

@@ -24,14 +24,13 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
WifiApIface::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)
WifiApIface::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)
: ifname_(ifname),
instances_(instances),
legacy_hal_(legacy_hal),
@@ -43,14 +42,16 @@ void WifiApIface::invalidate() {
is_valid_ = false;
}
bool WifiApIface::isValid() { return is_valid_; }
bool WifiApIface::isValid() {
return is_valid_;
}
std::string WifiApIface::getName() { return ifname_; }
std::string WifiApIface::getName() {
return ifname_;
}
void WifiApIface::removeInstance(std::string instance) {
instances_.erase(
std::remove(instances_.begin(), instances_.end(), instance),
instances_.end());
instances_.erase(std::remove(instances_.begin(), instances_.end(), instance), instances_.end());
}
Return<void> WifiApIface::getName(getName_cb hidl_status_cb) {
@@ -66,44 +67,35 @@ Return<void> WifiApIface::getType(getType_cb hidl_status_cb) {
Return<void> WifiApIface::setCountryCode(const hidl_array<int8_t, 2>& code,
setCountryCode_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::setCountryCodeInternal, hidl_status_cb,
code);
&WifiApIface::setCountryCodeInternal, hidl_status_cb, code);
}
Return<void> WifiApIface::getValidFrequenciesForBand(
V1_0::WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) {
Return<void> WifiApIface::getValidFrequenciesForBand(V1_0::WifiBand band,
getValidFrequenciesForBand_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getValidFrequenciesForBandInternal,
hidl_status_cb, band);
&WifiApIface::getValidFrequenciesForBandInternal, hidl_status_cb, band);
}
Return<void> WifiApIface::setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::setMacAddressInternal, hidl_status_cb,
mac);
&WifiApIface::setMacAddressInternal, hidl_status_cb, mac);
}
Return<void> WifiApIface::getFactoryMacAddress(
getFactoryMacAddress_cb hidl_status_cb) {
Return<void> WifiApIface::getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getFactoryMacAddressInternal,
hidl_status_cb,
&WifiApIface::getFactoryMacAddressInternal, hidl_status_cb,
instances_.size() > 0 ? instances_[0] : ifname_);
}
Return<void> WifiApIface::resetToFactoryMacAddress(
resetToFactoryMacAddress_cb hidl_status_cb) {
Return<void> WifiApIface::resetToFactoryMacAddress(resetToFactoryMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::resetToFactoryMacAddressInternal,
hidl_status_cb);
&WifiApIface::resetToFactoryMacAddressInternal, hidl_status_cb);
}
Return<void> WifiApIface::getBridgedInstances(
getBridgedInstances_cb hidl_status_cb) {
Return<void> WifiApIface::getBridgedInstances(getBridgedInstances_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getBridgedInstancesInternal,
hidl_status_cb);
&WifiApIface::getBridgedInstancesInternal, hidl_status_cb);
}
std::pair<WifiStatus, std::string> WifiApIface::getNameInternal() {
@@ -114,28 +106,24 @@ std::pair<WifiStatus, IfaceType> WifiApIface::getTypeInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::AP};
}
WifiStatus WifiApIface::setCountryCodeInternal(
const std::array<int8_t, 2>& code) {
WifiStatus WifiApIface::setCountryCodeInternal(const std::array<int8_t, 2>& code) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setCountryCode(
instances_.size() > 0 ? instances_[0] : ifname_, code);
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");
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(
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};
}
WifiStatus WifiApIface::setMacAddressInternal(
const std::array<uint8_t, 6>& mac) {
WifiStatus WifiApIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
// Support random MAC up to 2 interfaces
if (instances_.size() == 2) {
int rbyte = 1;
@@ -160,12 +148,10 @@ WifiStatus WifiApIface::setMacAddressInternal(
return createWifiStatus(WifiStatusCode::SUCCESS);
}
std::pair<WifiStatus, std::array<uint8_t, 6>>
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) {
std::pair<WifiStatus, std::array<uint8_t, 6>> 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 {createWifiStatus(WifiStatusCode::SUCCESS), mac};
@@ -188,10 +174,9 @@ WifiStatus WifiApIface::resetToFactoryMacAddressInternal() {
// 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.
if (!iface_util_.lock()->setMacAddress(
ifname_, iface_util_.lock()->createRandomMacAddress())) {
LOG(ERROR) << "Fail to config MAC for bridged interface "
<< ifname_;
if (!iface_util_.lock()->setMacAddress(ifname_,
iface_util_.lock()->createRandomMacAddress())) {
LOG(ERROR) << "Fail to config MAC for bridged interface " << ifname_;
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
} else {
@@ -205,8 +190,7 @@ WifiStatus WifiApIface::resetToFactoryMacAddressInternal() {
return createWifiStatus(WifiStatusCode::SUCCESS);
}
std::pair<WifiStatus, std::vector<hidl_string>>
WifiApIface::getBridgedInstancesInternal() {
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);
@@ -214,7 +198,7 @@ WifiApIface::getBridgedInstancesInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), instances};
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

34
wifi/1.5/default/wifi_ap_iface.h → wifi/1.6/default/wifi_ap_iface.h
View File

@@ -26,7 +26,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
@@ -34,9 +34,8 @@ 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,
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()|.
@@ -50,32 +49,27 @@ class WifiApIface : public V1_5::IWifiApIface {
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> 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> 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;
Return<void> getBridgedInstances(getBridgedInstances_cb hidl_status_cb) override;
private:
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);
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);
const std::string& ifaceName);
WifiStatus resetToFactoryMacAddressInternal();
std::pair<WifiStatus, std::vector<hidl_string>>
getBridgedInstancesInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getBridgedInstancesInternal();
std::string ifname_;
std::vector<std::string> instances_;
@@ -87,7 +81,7 @@ class WifiApIface : public V1_5::IWifiApIface {
};
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

804
wifi/1.5/default/wifi_chip.cpp → wifi/1.6/default/wifi_chip.cpp
View File

File diff suppressed because it is too large Load Diff

249
wifi/1.5/default/wifi_chip.h → wifi/1.6/default/wifi_chip.h
View File

@@ -39,9 +39,11 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using V1_5::WifiBand;
using V1_5::WifiUsableChannel;
/**
* HIDL interface object used to control a Wifi HAL chip instance.
@@ -49,15 +51,13 @@ using namespace android::hardware::wifi::V1_0;
* identifying handle information stored here.
*/
class WifiChip : public V1_5::IWifiChip {
public:
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::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);
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
@@ -78,116 +78,84 @@ class WifiChip : public V1_5::IWifiChip {
// 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> 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> 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> 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> 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> 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;
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> 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> 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> 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> 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;
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;
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;
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;
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<WifiIfaceMode> ifaceModeMask,
hidl_bitfield<UsableChannelFilter> filterMask,
getUsableChannels_cb _hidl_cb) override;
Return<void> triggerSubsystemRestart(
triggerSubsystemRestart_cb hidl_status_cb) override;
Return<void> getUsableChannels(WifiBand band, hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
hidl_bitfield<UsableChannelFilter> filterMask,
getUsableChannels_cb _hidl_cb) override;
Return<void> triggerSubsystemRestart(triggerSubsystemRestart_cb hidl_status_cb) override;
private:
private:
void invalidateAndRemoveAllIfaces();
// When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are
// invalidated & removed.
@@ -197,99 +165,83 @@ class WifiChip : public V1_5::IWifiChip {
std::pair<WifiStatus, ChipId> getIdInternal();
// Deprecated support for this callback
WifiStatus registerEventCallbackInternal(
const sp<V1_0::IWifiChipEventCallback>& event_callback);
const sp<V1_0::IWifiChipEventCallback>& event_callback);
std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
std::pair<WifiStatus, std::vector<ChipMode>> getAvailableModesInternal();
WifiStatus configureChipInternal(
std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id);
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();
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, 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);
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);
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);
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);
std::pair<WifiStatus, sp<IWifiP2pIface>> getP2pIfaceInternal(const std::string& ifname);
WifiStatus removeP2pIfaceInternal(const std::string& ifname);
std::pair<WifiStatus, sp<V1_5::IWifiStaIface>> createStaIfaceInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal();
std::pair<WifiStatus, sp<V1_5::IWifiStaIface>> getStaIfaceInternal(
const std::string& ifname);
std::pair<WifiStatus, sp<V1_5::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, 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 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();
std::pair<WifiStatus, WifiDebugHostWakeReasonStats> getDebugHostWakeReasonStatsInternal();
WifiStatus enableDebugErrorAlertsInternal(bool enable);
WifiStatus selectTxPowerScenarioInternal(
V1_1::IWifiChip::TxPowerScenario scenario);
WifiStatus selectTxPowerScenarioInternal(V1_1::IWifiChip::TxPowerScenario scenario);
WifiStatus resetTxPowerScenarioInternal();
WifiStatus setLatencyModeInternal(LatencyMode mode);
WifiStatus registerEventCallbackInternal_1_2(
const sp<V1_2::IWifiChipEventCallback>& event_callback);
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);
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);
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 setCoexUnsafeChannelsInternal(std::vector<CoexUnsafeChannel> unsafe_channels,
uint32_t restrictions);
WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code);
std::pair<WifiStatus, std::vector<WifiUsableChannel>>
getUsableChannelsInternal(WifiBand band, uint32_t ifaceModeMask,
uint32_t filterMask);
WifiStatus handleChipConfiguration(
std::unique_lock<std::recursive_mutex>* lock, ChipModeId mode_id);
std::pair<WifiStatus, std::vector<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_4::IWifiChip::ChipIfaceCombination>
getCurrentModeIfaceCombinations();
std::vector<V1_4::IWifiChip::ChipIfaceCombination> getCurrentModeIfaceCombinations();
std::map<IfaceType, size_t> getCurrentIfaceCombination();
std::vector<std::map<IfaceType, size_t>> expandIfaceCombinations(
const V1_4::IWifiChip::ChipIfaceCombination& combination);
const V1_4::IWifiChip::ChipIfaceCombination& combination);
bool canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces(
const std::map<IfaceType, size_t>& expanded_combo,
IfaceType requested_type);
bool canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(
IfaceType requested_type);
bool canExpandedIfaceComboSupportIfaceCombo(
const std::map<IfaceType, size_t>& expanded_combo,
const std::map<IfaceType, size_t>& req_combo);
bool canCurrentModeSupportIfaceCombo(
const std::map<IfaceType, size_t>& req_combo);
const std::map<IfaceType, size_t>& expanded_combo, IfaceType requested_type);
bool canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType requested_type);
bool canExpandedIfaceComboSupportIfaceCombo(const std::map<IfaceType, size_t>& expanded_combo,
const std::map<IfaceType, size_t>& req_combo);
bool canCurrentModeSupportIfaceCombo(const std::map<IfaceType, size_t>& req_combo);
bool canCurrentModeSupportIfaceOfType(IfaceType requested_type);
bool isValidModeId(ChipModeId mode_id);
bool isStaApConcurrencyAllowedInCurrentMode();
@@ -326,8 +278,7 @@ class WifiChip : public V1_5::IWifiChip {
// 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_;
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_;
@@ -335,7 +286,7 @@ class WifiChip : public V1_5::IWifiChip {
};
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

47
wifi/1.5/default/wifi_feature_flags.cpp → wifi/1.6/default/wifi_feature_flags.cpp
View File

@@ -24,7 +24,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
@@ -117,18 +117,16 @@ constexpr ChipModeId kMainModeId = chip_mode_ids::kV1Sta;
* The main point here is to simplify the syntax required by
* WIFI_HAL_INTERFACE_COMBINATIONS.
*/
struct ChipIfaceCombination
: public hidl_vec<IWifiChip::ChipIfaceCombinationLimit> {
ChipIfaceCombination(
const std::initializer_list<IWifiChip::ChipIfaceCombinationLimit> list)
struct ChipIfaceCombination : public hidl_vec<IWifiChip::ChipIfaceCombinationLimit> {
ChipIfaceCombination(const std::initializer_list<IWifiChip::ChipIfaceCombinationLimit> list)
: hidl_vec(list) {}
operator IWifiChip::ChipIfaceCombination() const { return {*this}; }
static hidl_vec<IWifiChip::ChipIfaceCombination> make_vec(
const std::initializer_list<ChipIfaceCombination> list) {
const std::initializer_list<ChipIfaceCombination> list) {
return hidl_vec<IWifiChip::ChipIfaceCombination>( //
std::begin(list), std::end(list));
std::begin(list), std::end(list));
}
};
@@ -137,23 +135,22 @@ struct ChipIfaceCombination
#define P2P IfaceType::P2P
#define NAN IfaceType::NAN
static const std::vector<IWifiChip::ChipMode> kChipModesPrimary{
{kMainModeId,
ChipIfaceCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS})},
{kMainModeId, ChipIfaceCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS})},
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_AP
{chip_mode_ids::kV1Ap,
ChipIfaceCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_AP})},
{chip_mode_ids::kV1Ap,
ChipIfaceCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_AP})},
#endif
};
static const std::vector<IWifiChip::ChipMode> kChipModesSecondary{
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP
{chip_mode_ids::kV3, ChipIfaceCombination::make_vec(
{WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP})},
{chip_mode_ids::kV3,
ChipIfaceCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP})},
#endif
};
constexpr char kDebugPresetInterfaceCombinationIdxProperty[] =
"persist.vendor.debug.wifi.hal.preset_interface_combination_idx";
"persist.vendor.debug.wifi.hal.preset_interface_combination_idx";
// List of pre-defined interface combinations that can be enabled at runtime via
// setting the property: "kDebugPresetInterfaceCombinationIdxProperty" to the
// corresponding index value.
@@ -200,19 +197,18 @@ static const std::vector<std::pair<std::string, std::vector<IWifiChip::ChipMode>
#undef NAN
#ifdef WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
#pragma message \
"WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION is deprecated; override " \
"'config_wifi_ap_randomization_supported' in " \
"frameworks/base/core/res/res/values/config.xml in the device overlay " \
"instead"
#pragma message \
"WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION is deprecated; override " \
"'config_wifi_ap_randomization_supported' in " \
"frameworks/base/core/res/res/values/config.xml in the device overlay " \
"instead"
#endif // WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
WifiFeatureFlags::WifiFeatureFlags() {}
std::vector<IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary() {
std::array<char, PROPERTY_VALUE_MAX> buffer;
auto res = property_get(kDebugPresetInterfaceCombinationIdxProperty,
buffer.data(), nullptr);
auto res = property_get(kDebugPresetInterfaceCombinationIdxProperty, buffer.data(), nullptr);
// Debug propety not set, use the device preset interface combination.
if (res <= 0) return kChipModesPrimary;
@@ -226,19 +222,18 @@ std::vector<IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary() {
std::string name;
std::vector<IWifiChip::ChipMode> chip_modes;
std::tie(name, chip_modes) = kDebugChipModes[idx];
LOG(INFO) << "Using debug chip mode: <" << name << "> set via property: "
<< kDebugPresetInterfaceCombinationIdxProperty;
LOG(INFO) << "Using debug chip mode: <" << name
<< "> set via property: " << kDebugPresetInterfaceCombinationIdxProperty;
return chip_modes;
}
std::vector<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_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

11
wifi/1.5/default/wifi_feature_flags.h → wifi/1.6/default/wifi_feature_flags.h
View File

@@ -22,7 +22,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
@@ -38,20 +38,19 @@ constexpr V1_0::ChipModeId kV3 = 3;
} // namespace chip_mode_ids
class WifiFeatureFlags {
public:
public:
WifiFeatureFlags();
virtual ~WifiFeatureFlags() = default;
virtual std::vector<V1_0::IWifiChip::ChipMode> getChipModes(
bool is_primary);
virtual std::vector<V1_0::IWifiChip::ChipMode> getChipModes(bool is_primary);
private:
private:
std::vector<V1_0::IWifiChip::ChipMode> getChipModesForPrimary();
};
} // namespace feature_flags
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

34
wifi/1.5/default/wifi_iface_util.cpp → wifi/1.6/default/wifi_iface_util.cpp
View File

@@ -36,20 +36,18 @@ constexpr uint8_t kMacAddressLocallyAssignedMask = 0x02;
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace iface_util {
WifiIfaceUtil::WifiIfaceUtil(
const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
WifiIfaceUtil::WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: iface_tool_(iface_tool),
legacy_hal_(legacy_hal),
random_mac_address_(nullptr),
event_handlers_map_() {}
std::array<uint8_t, 6> WifiIfaceUtil::getFactoryMacAddress(
const std::string& iface_name) {
std::array<uint8_t, 6> WifiIfaceUtil::getFactoryMacAddress(const std::string& iface_name) {
return iface_tool_.lock()->GetFactoryMacAddress(iface_name.c_str());
}
@@ -59,7 +57,7 @@ bool WifiIfaceUtil::setMacAddress(const std::string& iface_name,
legacy_hal::wifi_error legacy_status;
uint64_t legacy_feature_set;
std::tie(legacy_status, legacy_feature_set) =
legacy_hal_.lock()->getSupportedFeatureSet(iface_name);
legacy_hal_.lock()->getSupportedFeatureSet(iface_name);
if (!(legacy_feature_set & WIFI_FEATURE_DYNAMIC_SET_MAC) &&
!iface_tool_.lock()->SetUpState(iface_name.c_str(), false)) {
@@ -73,8 +71,7 @@ bool WifiIfaceUtil::setMacAddress(const std::string& iface_name,
!iface_tool_.lock()->SetUpState(iface_name.c_str(), true)) {
LOG(ERROR) << "SetUpState(true) failed. Wait for driver ready.";
// Wait for driver ready and try to set iface UP again
if (legacy_hal_.lock()->waitForDriverReady() !=
legacy_hal::WIFI_SUCCESS) {
if (legacy_hal_.lock()->waitForDriverReady() != legacy_hal::WIFI_SUCCESS) {
LOG(ERROR) << "SetUpState(true) wait for driver ready failed.";
return false;
}
@@ -104,8 +101,7 @@ std::array<uint8_t, 6> WifiIfaceUtil::getOrCreateRandomMacAddress() {
if (random_mac_address_) {
return *random_mac_address_.get();
}
random_mac_address_ =
std::make_unique<std::array<uint8_t, 6>>(createRandomMacAddress());
random_mac_address_ = std::make_unique<std::array<uint8_t, 6>>(createRandomMacAddress());
return *random_mac_address_.get();
}
@@ -114,8 +110,7 @@ void WifiIfaceUtil::registerIfaceEventHandlers(const std::string& iface_name,
event_handlers_map_[iface_name] = handlers;
}
void WifiIfaceUtil::unregisterIfaceEventHandlers(
const std::string& iface_name) {
void WifiIfaceUtil::unregisterIfaceEventHandlers(const std::string& iface_name) {
event_handlers_map_.erase(iface_name);
}
@@ -123,9 +118,8 @@ std::array<uint8_t, 6> WifiIfaceUtil::createRandomMacAddress() {
std::array<uint8_t, 6> address = {};
std::random_device rd;
std::default_random_engine engine(rd());
std::uniform_int_distribution<uint8_t> dist(
std::numeric_limits<uint8_t>::min(),
std::numeric_limits<uint8_t>::max());
std::uniform_int_distribution<uint8_t> dist(std::numeric_limits<uint8_t>::min(),
std::numeric_limits<uint8_t>::max());
for (size_t i = 0; i < address.size(); i++) {
address[i] = dist(engine);
}
@@ -166,19 +160,17 @@ bool WifiIfaceUtil::deleteBridge(const std::string& br_name) {
return iface_tool_.lock()->deleteBridge(br_name);
}
bool WifiIfaceUtil::addIfaceToBridge(const std::string& br_name,
const std::string& if_name) {
bool WifiIfaceUtil::addIfaceToBridge(const std::string& br_name, const std::string& if_name) {
return iface_tool_.lock()->addIfaceToBridge(br_name, if_name);
}
bool WifiIfaceUtil::removeIfaceFromBridge(const std::string& br_name,
const std::string& if_name) {
bool WifiIfaceUtil::removeIfaceFromBridge(const std::string& br_name, const std::string& if_name) {
return iface_tool_.lock()->removeIfaceFromBridge(br_name, if_name);
}
} // namespace iface_util
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

20
wifi/1.5/default/wifi_iface_util.h → wifi/1.6/default/wifi_iface_util.h
View File

@@ -26,7 +26,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace iface_util {
@@ -41,15 +41,13 @@ struct IfaceEventHandlers {
* Util class for common iface operations.
*/
class WifiIfaceUtil {
public:
public:
WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
virtual ~WifiIfaceUtil() = default;
virtual std::array<uint8_t, 6> getFactoryMacAddress(
const std::string& iface_name);
virtual bool setMacAddress(const std::string& iface_name,
const std::array<uint8_t, 6>& mac);
virtual std::array<uint8_t, 6> getFactoryMacAddress(const std::string& iface_name);
virtual bool setMacAddress(const std::string& iface_name, const std::array<uint8_t, 6>& mac);
// Get or create a random MAC address. The MAC address returned from
// this method will remain the same throughout the lifetime of the HAL
// daemon. (So, changes on every reboot)
@@ -66,15 +64,13 @@ class WifiIfaceUtil {
virtual bool deleteBridge(const std::string& br_name);
virtual bool addIfaceToBridge(const std::string& br_name,
const std::string& if_name);
virtual bool addIfaceToBridge(const std::string& br_name, const std::string& if_name);
virtual bool removeIfaceFromBridge(const std::string& br_name,
const std::string& if_name);
virtual bool removeIfaceFromBridge(const std::string& br_name, const std::string& if_name);
// Get a random MAC address.
virtual std::array<uint8_t, 6> createRandomMacAddress();
private:
private:
std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::unique_ptr<std::array<uint8_t, 6>> random_mac_address_;
@@ -83,7 +79,7 @@ class WifiIfaceUtil {
} // namespace iface_util
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

1111
wifi/1.5/default/wifi_legacy_hal.cpp → wifi/1.6/default/wifi_legacy_hal.cpp
View File

File diff suppressed because it is too large Load Diff

303
wifi/1.5/default/wifi_legacy_hal.h → wifi/1.6/default/wifi_legacy_hal.h
View File

@@ -29,7 +29,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
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.
@@ -366,63 +366,53 @@ struct WakeReasonStats {
// NAN response and event callbacks struct.
struct NanCallbackHandlers {
// NotifyResponse invoked to notify the status of the Request.
std::function<void(transaction_id, const NanResponseMsg&)>
on_notify_response;
std::function<void(transaction_id, const NanResponseMsg&)> on_notify_response;
// Various event callbacks.
std::function<void(const NanPublishTerminatedInd&)>
on_event_publish_terminated;
std::function<void(const NanPublishTerminatedInd&)> on_event_publish_terminated;
std::function<void(const NanMatchInd&)> on_event_match;
std::function<void(const NanMatchExpiredInd&)> on_event_match_expired;
std::function<void(const NanSubscribeTerminatedInd&)>
on_event_subscribe_terminated;
std::function<void(const NanSubscribeTerminatedInd&)> on_event_subscribe_terminated;
std::function<void(const NanFollowupInd&)> on_event_followup;
std::function<void(const NanDiscEngEventInd&)> on_event_disc_eng_event;
std::function<void(const NanDisabledInd&)> on_event_disabled;
std::function<void(const NanTCAInd&)> on_event_tca;
std::function<void(const NanBeaconSdfPayloadInd&)>
on_event_beacon_sdf_payload;
std::function<void(const NanDataPathRequestInd&)>
on_event_data_path_request;
std::function<void(const NanDataPathConfirmInd&)>
on_event_data_path_confirm;
std::function<void(const NanBeaconSdfPayloadInd&)> on_event_beacon_sdf_payload;
std::function<void(const NanDataPathRequestInd&)> on_event_data_path_request;
std::function<void(const NanDataPathConfirmInd&)> on_event_data_path_confirm;
std::function<void(const NanDataPathEndInd&)> on_event_data_path_end;
std::function<void(const NanTransmitFollowupInd&)>
on_event_transmit_follow_up;
std::function<void(const NanTransmitFollowupInd&)> on_event_transmit_follow_up;
std::function<void(const NanRangeRequestInd&)> on_event_range_request;
std::function<void(const NanRangeReportInd&)> on_event_range_report;
std::function<void(const NanDataPathScheduleUpdateInd&)>
on_event_schedule_update;
std::function<void(const NanDataPathScheduleUpdateInd&)> on_event_schedule_update;
};
// Full scan results contain IE info and are hence passed by reference, to
// preserve the variable length array member |ie_data|. Callee must not retain
// the pointer.
using on_gscan_full_result_callback =
std::function<void(wifi_request_id, const wifi_scan_result*, uint32_t)>;
std::function<void(wifi_request_id, const wifi_scan_result*, uint32_t)>;
// These scan results don't contain any IE info, so no need to pass by
// reference.
using on_gscan_results_callback = std::function<void(
wifi_request_id, const std::vector<wifi_cached_scan_results>&)>;
using on_gscan_results_callback =
std::function<void(wifi_request_id, const std::vector<wifi_cached_scan_results>&)>;
// 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, 6>, int8_t)>;
// Callback for RTT range request results.
// Rtt results contain IE info and are hence passed by reference, to
// preserve the |LCI| and |LCR| pointers. Callee must not retain
// the pointer.
using on_rtt_results_callback = std::function<void(
wifi_request_id, const std::vector<const wifi_rtt_result*>&)>;
using on_rtt_results_callback =
std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result*>&)>;
// Callback for ring buffer data.
using on_ring_buffer_data_callback =
std::function<void(const std::string&, const std::vector<uint8_t>&,
const wifi_ring_buffer_status&)>;
using on_ring_buffer_data_callback = std::function<void(
const std::string&, const std::vector<uint8_t>&, const wifi_ring_buffer_status&)>;
// Callback for alerts.
using on_error_alert_callback =
std::function<void(int32_t, const std::vector<uint8_t>&)>;
using on_error_alert_callback = std::function<void(int32_t, const std::vector<uint8_t>&)>;
// Callback for subsystem restart
using on_subsystem_restart_callback = std::function<void(const std::string&)>;
@@ -443,8 +433,7 @@ typedef struct {
} WifiMacInfo;
// Callback for radio mode change
using on_radio_mode_change_callback =
std::function<void(const std::vector<WifiMacInfo>&)>;
using on_radio_mode_change_callback = std::function<void(const std::vector<WifiMacInfo>&)>;
// TWT response and event callbacks struct.
struct TwtCallbackHandlers {
@@ -466,9 +455,9 @@ struct TwtCallbackHandlers {
* object and will be valid for the lifetime of the process.
*/
class WifiLegacyHal {
public:
WifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary);
public:
WifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool, const wifi_hal_fn& fn,
bool is_primary);
virtual ~WifiLegacyHal() = default;
// Initialize the legacy HAL function table.
@@ -483,26 +472,22 @@ class WifiLegacyHal {
// Checks if legacy HAL has successfully started
bool isStarted();
// Wrappers for all the functions in the legacy HAL function table.
virtual std::pair<wifi_error, std::string> getDriverVersion(
const std::string& iface_name);
virtual std::pair<wifi_error, std::string> getFirmwareVersion(
const std::string& iface_name);
virtual std::pair<wifi_error, std::string> getDriverVersion(const std::string& iface_name);
virtual std::pair<wifi_error, std::string> getFirmwareVersion(const std::string& iface_name);
std::pair<wifi_error, std::vector<uint8_t>> requestDriverMemoryDump(
const std::string& iface_name);
const std::string& iface_name);
std::pair<wifi_error, std::vector<uint8_t>> requestFirmwareMemoryDump(
const std::string& iface_name);
std::pair<wifi_error, uint64_t> getSupportedFeatureSet(
const std::string& iface_name);
const std::string& iface_name);
std::pair<wifi_error, uint64_t> getSupportedFeatureSet(const std::string& iface_name);
// APF functions.
std::pair<wifi_error, PacketFilterCapabilities> getPacketFilterCapabilities(
const std::string& iface_name);
wifi_error setPacketFilter(const std::string& iface_name,
const std::vector<uint8_t>& program);
const std::string& iface_name);
wifi_error setPacketFilter(const std::string& iface_name, const std::vector<uint8_t>& program);
std::pair<wifi_error, std::vector<uint8_t>> readApfPacketFilterData(
const std::string& iface_name);
const std::string& iface_name);
// Gscan functions.
std::pair<wifi_error, wifi_gscan_capabilities> getGscanCapabilities(
const std::string& iface_name);
const std::string& iface_name);
// These API's provides a simplified interface over the legacy Gscan API's:
// a) All scan events from the legacy HAL API other than the
// |WIFI_SCAN_FAILED| are treated as notification of results.
@@ -514,162 +499,121 @@ class WifiLegacyHal {
// 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,
const wifi_scan_cmd_params& params,
const std::function<void(wifi_request_id)>& on_failure_callback,
const on_gscan_results_callback& on_results_callback,
const on_gscan_full_result_callback& on_full_result_callback);
wifi_error startGscan(const std::string& iface_name, wifi_request_id id,
const wifi_scan_cmd_params& params,
const std::function<void(wifi_request_id)>& on_failure_callback,
const on_gscan_results_callback& on_results_callback,
const on_gscan_full_result_callback& on_full_result_callback);
wifi_error stopGscan(const std::string& iface_name, wifi_request_id id);
std::pair<wifi_error, std::vector<uint32_t>> getValidFrequenciesForBand(
const std::string& iface_name, wifi_band band);
const std::string& iface_name, wifi_band band);
virtual wifi_error setDfsFlag(const std::string& iface_name, bool dfs_on);
// Link layer stats functions.
wifi_error enableLinkLayerStats(const std::string& iface_name, bool debug);
wifi_error disableLinkLayerStats(const std::string& iface_name);
std::pair<wifi_error, LinkLayerStats> getLinkLayerStats(
const std::string& iface_name);
std::pair<wifi_error, LinkLayerStats> getLinkLayerStats(const std::string& iface_name);
// RSSI monitor functions.
wifi_error startRssiMonitoring(const std::string& iface_name,
wifi_request_id id, int8_t max_rssi,
int8_t min_rssi,
const on_rssi_threshold_breached_callback&
on_threshold_breached_callback);
wifi_error stopRssiMonitoring(const std::string& iface_name,
wifi_request_id id);
wifi_error startRssiMonitoring(
const std::string& iface_name, wifi_request_id id, int8_t max_rssi, int8_t min_rssi,
const on_rssi_threshold_breached_callback& on_threshold_breached_callback);
wifi_error stopRssiMonitoring(const std::string& iface_name, wifi_request_id id);
std::pair<wifi_error, wifi_roaming_capabilities> getRoamingCapabilities(
const std::string& iface_name);
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);
const std::string& iface_name);
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, 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);
wifi_error stopSendingOffloadedPacket(const std::string& iface_name,
uint32_t cmd_id);
wifi_error startSendingOffloadedPacket(const std::string& iface_name, uint32_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);
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);
virtual wifi_error resetTxPowerScenario(const std::string& iface_name);
wifi_error setLatencyMode(const std::string& iface_name,
wifi_latency_mode mode);
wifi_error setThermalMitigationMode(wifi_thermal_mode mode,
uint32_t completion_window);
wifi_error setLatencyMode(const std::string& iface_name, wifi_latency_mode mode);
wifi_error setThermalMitigationMode(wifi_thermal_mode mode, uint32_t completion_window);
wifi_error setDscpToAccessCategoryMapping(uint32_t start, uint32_t end,
uint32_t access_category);
wifi_error resetDscpToAccessCategoryMapping();
// Logger/debug functions.
std::pair<wifi_error, uint32_t> getLoggerSupportedFeatureSet(
const std::string& iface_name);
std::pair<wifi_error, uint32_t> getLoggerSupportedFeatureSet(const std::string& iface_name);
wifi_error startPktFateMonitoring(const std::string& iface_name);
std::pair<wifi_error, std::vector<wifi_tx_report>> getTxPktFates(
const std::string& iface_name);
std::pair<wifi_error, std::vector<wifi_rx_report>> getRxPktFates(
const std::string& iface_name);
std::pair<wifi_error, WakeReasonStats> getWakeReasonStats(
const std::string& iface_name);
std::pair<wifi_error, std::vector<wifi_tx_report>> getTxPktFates(const std::string& iface_name);
std::pair<wifi_error, std::vector<wifi_rx_report>> getRxPktFates(const std::string& iface_name);
std::pair<wifi_error, WakeReasonStats> getWakeReasonStats(const std::string& iface_name);
wifi_error registerRingBufferCallbackHandler(
const std::string& iface_name,
const on_ring_buffer_data_callback& on_data_callback);
wifi_error deregisterRingBufferCallbackHandler(
const std::string& iface_name);
const std::string& iface_name, const on_ring_buffer_data_callback& on_data_callback);
wifi_error deregisterRingBufferCallbackHandler(const std::string& iface_name);
wifi_error registerSubsystemRestartCallbackHandler(
const on_subsystem_restart_callback& on_restart_callback);
std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
getRingBuffersStatus(const std::string& iface_name);
wifi_error startRingBufferLogging(const std::string& iface_name,
const std::string& ring_name,
uint32_t verbose_level,
uint32_t max_interval_sec,
const on_subsystem_restart_callback& on_restart_callback);
std::pair<wifi_error, std::vector<wifi_ring_buffer_status>> getRingBuffersStatus(
const std::string& iface_name);
wifi_error startRingBufferLogging(const std::string& iface_name, const std::string& ring_name,
uint32_t verbose_level, uint32_t max_interval_sec,
uint32_t min_data_size);
wifi_error getRingBufferData(const std::string& iface_name,
const std::string& ring_name);
wifi_error registerErrorAlertCallbackHandler(
const std::string& iface_name,
const on_error_alert_callback& on_alert_callback);
wifi_error deregisterErrorAlertCallbackHandler(
const std::string& iface_name);
wifi_error getRingBufferData(const std::string& iface_name, const std::string& ring_name);
wifi_error registerErrorAlertCallbackHandler(const std::string& iface_name,
const on_error_alert_callback& on_alert_callback);
wifi_error deregisterErrorAlertCallbackHandler(const std::string& iface_name);
// Radio mode functions.
virtual wifi_error registerRadioModeChangeCallbackHandler(
const std::string& iface_name,
const on_radio_mode_change_callback& on_user_change_callback);
const std::string& iface_name,
const on_radio_mode_change_callback& on_user_change_callback);
// RTT functions.
wifi_error startRttRangeRequest(
const std::string& iface_name, wifi_request_id id,
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);
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,
const wifi_channel_info& channel_hint,
uint32_t max_duration_secs,
wifi_error startRttRangeRequest(const std::string& iface_name, wifi_request_id id,
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);
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,
const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
const wifi_rtt_responder& info);
wifi_error disableRttResponder(const std::string& iface_name,
wifi_request_id id);
wifi_error disableRttResponder(const std::string& iface_name, wifi_request_id id);
wifi_error setRttLci(const std::string& iface_name, wifi_request_id id,
const wifi_lci_information& info);
wifi_error setRttLcr(const std::string& iface_name, wifi_request_id id,
const wifi_lcr_information& info);
// NAN functions.
virtual wifi_error nanRegisterCallbackHandlers(
const std::string& iface_name, const NanCallbackHandlers& callbacks);
wifi_error nanEnableRequest(const std::string& iface_name,
transaction_id id, const NanEnableRequest& msg);
virtual wifi_error nanDisableRequest(const std::string& iface_name,
transaction_id id);
wifi_error nanPublishRequest(const std::string& iface_name,
transaction_id id,
virtual wifi_error nanRegisterCallbackHandlers(const std::string& iface_name,
const NanCallbackHandlers& callbacks);
wifi_error nanEnableRequest(const std::string& iface_name, transaction_id id,
const NanEnableRequest& msg);
virtual wifi_error nanDisableRequest(const std::string& iface_name, transaction_id id);
wifi_error nanPublishRequest(const std::string& iface_name, transaction_id id,
const NanPublishRequest& msg);
wifi_error nanPublishCancelRequest(const std::string& iface_name,
transaction_id id,
wifi_error nanPublishCancelRequest(const std::string& iface_name, transaction_id id,
const NanPublishCancelRequest& msg);
wifi_error nanSubscribeRequest(const std::string& iface_name,
transaction_id id,
wifi_error nanSubscribeRequest(const std::string& iface_name, transaction_id id,
const NanSubscribeRequest& msg);
wifi_error nanSubscribeCancelRequest(const std::string& iface_name,
transaction_id id,
wifi_error nanSubscribeCancelRequest(const std::string& iface_name, transaction_id id,
const NanSubscribeCancelRequest& msg);
wifi_error nanTransmitFollowupRequest(
const std::string& iface_name, transaction_id id,
const NanTransmitFollowupRequest& msg);
wifi_error nanTransmitFollowupRequest(const std::string& iface_name, transaction_id id,
const NanTransmitFollowupRequest& msg);
wifi_error nanStatsRequest(const std::string& iface_name, transaction_id id,
const NanStatsRequest& msg);
wifi_error nanConfigRequest(const std::string& iface_name,
transaction_id id, const NanConfigRequest& msg);
wifi_error nanConfigRequest(const std::string& iface_name, transaction_id id,
const NanConfigRequest& msg);
wifi_error nanTcaRequest(const std::string& iface_name, transaction_id id,
const NanTCARequest& msg);
wifi_error nanBeaconSdfPayloadRequest(
const std::string& iface_name, transaction_id id,
const NanBeaconSdfPayloadRequest& msg);
wifi_error nanBeaconSdfPayloadRequest(const std::string& iface_name, transaction_id id,
const NanBeaconSdfPayloadRequest& msg);
std::pair<wifi_error, NanVersion> nanGetVersion();
wifi_error nanGetCapabilities(const std::string& iface_name,
transaction_id id);
wifi_error nanDataInterfaceCreate(const std::string& iface_name,
transaction_id id,
wifi_error nanGetCapabilities(const std::string& iface_name, transaction_id id);
wifi_error nanDataInterfaceCreate(const std::string& iface_name, transaction_id id,
const std::string& data_iface_name);
virtual wifi_error nanDataInterfaceDelete(
const std::string& iface_name, transaction_id id,
const std::string& data_iface_name);
wifi_error nanDataRequestInitiator(const std::string& iface_name,
transaction_id id,
virtual wifi_error nanDataInterfaceDelete(const std::string& iface_name, transaction_id id,
const std::string& data_iface_name);
wifi_error nanDataRequestInitiator(const std::string& iface_name, transaction_id id,
const NanDataPathInitiatorRequest& msg);
wifi_error nanDataIndicationResponse(
const std::string& iface_name, transaction_id id,
const NanDataPathIndicationResponse& msg);
wifi_error nanDataEnd(const std::string& iface_name, transaction_id id,
uint32_t ndpInstanceId);
wifi_error nanDataIndicationResponse(const std::string& iface_name, transaction_id id,
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, std::array<int8_t, 2> code);
// interface functions.
virtual wifi_error createVirtualInterface(const std::string& ifname,
@@ -682,43 +626,36 @@ class WifiLegacyHal {
virtual wifi_error multiStaSetUseCase(wifi_multi_sta_use_case use_case);
// Coex functions.
virtual wifi_error setCoexUnsafeChannels(
std::vector<wifi_coex_unsafe_channel> unsafe_channels,
uint32_t restrictions);
virtual wifi_error setCoexUnsafeChannels(std::vector<wifi_coex_unsafe_channel> unsafe_channels,
uint32_t restrictions);
wifi_error setVoipMode(const std::string& iface_name, wifi_voip_mode mode);
wifi_error twtRegisterHandler(const std::string& iface_name,
const TwtCallbackHandlers& handler);
std::pair<wifi_error, TwtCapabilitySet> twtGetCapability(
const std::string& iface_name);
std::pair<wifi_error, TwtCapabilitySet> twtGetCapability(const std::string& iface_name);
wifi_error twtSetupRequest(const std::string& iface_name,
const TwtSetupRequest& msg);
wifi_error twtSetupRequest(const std::string& iface_name, const TwtSetupRequest& msg);
wifi_error twtTearDownRequest(const std::string& iface_name,
const TwtTeardownRequest& msg);
wifi_error twtTearDownRequest(const std::string& iface_name, const TwtTeardownRequest& msg);
wifi_error twtInfoFrameRequest(const std::string& iface_name,
const TwtInfoFrameRequest& msg);
wifi_error twtInfoFrameRequest(const std::string& iface_name, const TwtInfoFrameRequest& msg);
std::pair<wifi_error, TwtStats> twtGetStats(const std::string& iface_name,
uint8_t configId);
std::pair<wifi_error, TwtStats> twtGetStats(const std::string& iface_name, uint8_t configId);
wifi_error twtClearStats(const std::string& iface_name, uint8_t configId);
wifi_error setDtimConfig(const std::string& iface_name,
uint32_t multiplier);
wifi_error setDtimConfig(const std::string& iface_name, uint32_t multiplier);
// Retrieve the list of usable channels in the requested bands
// for the requested modes
std::pair<wifi_error, std::vector<wifi_usable_channel>> getUsableChannels(
uint32_t band_mask, uint32_t iface_mode_mask, uint32_t filter_mask);
uint32_t band_mask, uint32_t iface_mode_mask, uint32_t filter_mask);
wifi_error triggerSubsystemRestart();
private:
private:
// Retrieve interface handles for all the available interfaces.
wifi_error retrieveIfaceHandles();
wifi_interface_handle getIfaceHandle(const std::string& iface_name);
@@ -726,12 +663,12 @@ class WifiLegacyHal {
void runEventLoop();
// Retrieve the cached gscan results to pass the results back to the
// external callbacks.
std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
getGscanCachedResults(const std::string& iface_name);
std::pair<wifi_error, std::vector<wifi_cached_scan_results>> getGscanCachedResults(
const std::string& iface_name);
void invalidate();
// Handles wifi (error) status of Virtual interface create/delete
wifi_error handleVirtualInterfaceCreateOrDeleteStatus(
const std::string& ifname, wifi_error status);
wifi_error handleVirtualInterfaceCreateOrDeleteStatus(const std::string& ifname,
wifi_error status);
// Global function table of legacy HAL.
wifi_hal_fn global_func_table_;
@@ -755,7 +692,7 @@ class WifiLegacyHal {
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

45
wifi/1.5/default/wifi_legacy_hal_factory.cpp → wifi/1.6/default/wifi_legacy_hal_factory.cpp
View File

@@ -62,22 +62,20 @@ bool isFileExtension(const char* name, const char* ext) {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
WifiLegacyHalFactory::WifiLegacyHalFactory(
const std::weak_ptr<wifi_system::InterfaceTool> iface_tool)
const std::weak_ptr<wifi_system::InterfaceTool> iface_tool)
: iface_tool_(iface_tool) {}
std::vector<std::shared_ptr<WifiLegacyHal>> WifiLegacyHalFactory::getHals() {
if (legacy_hals_.empty()) {
if (!initVendorHalDescriptorFromLinked())
initVendorHalsDescriptorList();
if (!initVendorHalDescriptorFromLinked()) initVendorHalsDescriptorList();
for (auto& desc : descs_) {
std::shared_ptr<WifiLegacyHal> hal =
std::make_shared<WifiLegacyHal>(iface_tool_, desc.fn,
desc.primary);
std::make_shared<WifiLegacyHal>(iface_tool_, desc.fn, desc.primary);
legacy_hals_.push_back(hal);
}
}
@@ -99,8 +97,8 @@ bool WifiLegacyHalFactory::initVendorHalDescriptorFromLinked() {
bool WifiLegacyHalFactory::initLinkedHalFunctionTable(wifi_hal_fn* hal_fn) {
init_wifi_vendor_hal_func_table_t initfn;
initfn = (init_wifi_vendor_hal_func_table_t)dlsym(
RTLD_DEFAULT, "init_wifi_vendor_hal_func_table");
initfn = (init_wifi_vendor_hal_func_table_t)dlsym(RTLD_DEFAULT,
"init_wifi_vendor_hal_func_table");
if (!initfn) {
LOG(INFO) << "no vendor HAL library linked, will try dynamic load";
return false;
@@ -136,8 +134,7 @@ void WifiLegacyHalFactory::initVendorHalsDescriptorList() {
xmlChar* value;
wifi_hal_lib_desc desc;
LOG(INFO) << "processing vendor HALs descriptions in "
<< kVendorHalsDescPath;
LOG(INFO) << "processing vendor HALs descriptions in " << kVendorHalsDescPath;
DIR* dirPtr = ::opendir(kVendorHalsDescPath);
if (dirPtr == NULL) {
LOG(ERROR) << "failed to open " << kVendorHalsDescPath;
@@ -157,26 +154,23 @@ void WifiLegacyHalFactory::initVendorHalsDescriptorList() {
fullPath.append(entryPtr->d_name);
xml = xmlReadFile(fullPath.c_str(), "UTF-8", XML_PARSE_RECOVER);
if (!xml) {
LOG(ERROR) << "failed to parse: " << entryPtr->d_name
<< " skipping...";
LOG(ERROR) << "failed to parse: " << entryPtr->d_name << " skipping...";
continue;
}
node = xmlDocGetRootElement(xml);
if (!node) {
LOG(ERROR) << "empty config file: " << entryPtr->d_name
<< " skipping...";
LOG(ERROR) << "empty config file: " << entryPtr->d_name << " skipping...";
goto skip;
}
if (xmlStrcmp(node->name, BAD_CAST "WifiVendorHal")) {
LOG(ERROR) << "bad config, root element not WifiVendorHal: "
<< entryPtr->d_name << " skipping...";
LOG(ERROR) << "bad config, root element not WifiVendorHal: " << entryPtr->d_name
<< " skipping...";
goto skip;
}
version = (char*)xmlGetProp(node, BAD_CAST "version");
if (!version || strtoul(version, NULL, 0) != kVendorHalsDescVersion) {
LOG(ERROR) << "conf file: " << entryPtr->d_name
<< "must have version: " << kVendorHalsDescVersion
<< ", skipping...";
<< "must have version: " << kVendorHalsDescVersion << ", skipping...";
goto skip;
}
cnode = node->children;
@@ -195,8 +189,8 @@ void WifiLegacyHalFactory::initVendorHalsDescriptorList() {
cnode = cnode->next;
}
if (path.empty()) {
LOG(ERROR) << "hal library path not provided in: "
<< entryPtr->d_name << ", skipping...";
LOG(ERROR) << "hal library path not provided in: " << entryPtr->d_name
<< ", skipping...";
goto skip;
}
if (loadVendorHalLib(path, desc)) {
@@ -211,8 +205,7 @@ void WifiLegacyHalFactory::initVendorHalsDescriptorList() {
::closedir(dirPtr);
}
bool WifiLegacyHalFactory::loadVendorHalLib(const std::string& path,
wifi_hal_lib_desc& desc) {
bool WifiLegacyHalFactory::loadVendorHalLib(const std::string& path, wifi_hal_lib_desc& desc) {
void* h = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
init_wifi_vendor_hal_func_table_t initfn;
wifi_error res;
@@ -221,8 +214,7 @@ bool WifiLegacyHalFactory::loadVendorHalLib(const std::string& path,
LOG(ERROR) << "failed to open vendor hal library: " << path;
return false;
}
initfn = (init_wifi_vendor_hal_func_table_t)dlsym(
h, "init_wifi_vendor_hal_func_table");
initfn = (init_wifi_vendor_hal_func_table_t)dlsym(h, "init_wifi_vendor_hal_func_table");
if (!initfn) {
LOG(ERROR) << "init_wifi_vendor_hal_func_table not found in: " << path;
goto out_err;
@@ -243,8 +235,7 @@ bool WifiLegacyHalFactory::loadVendorHalLib(const std::string& path,
// vendor HALs which do not implement early_initialize will return
// WIFI_ERROR_NOT_SUPPORTED, treat this as success.
if (res != WIFI_SUCCESS && res != WIFI_ERROR_NOT_SUPPORTED) {
LOG(ERROR) << "early initialization failed in: " << path
<< " error: " << res;
LOG(ERROR) << "early initialization failed in: " << path << " error: " << res;
goto out_err;
}
@@ -257,7 +248,7 @@ out_err:
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

11
wifi/1.5/default/wifi_legacy_hal_factory.h → wifi/1.6/default/wifi_legacy_hal_factory.h
View File

@@ -24,7 +24,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
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.
@@ -33,14 +33,13 @@ 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);
public:
WifiLegacyHalFactory(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool);
virtual ~WifiLegacyHalFactory() = default;
std::vector<std::shared_ptr<WifiLegacyHal>> getHals();
private:
private:
typedef struct {
wifi_hal_fn fn;
bool primary;
@@ -59,7 +58,7 @@ class WifiLegacyHalFactory {
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

4
wifi/1.5/default/wifi_legacy_hal_stubs.cpp → wifi/1.6/default/wifi_legacy_hal_stubs.cpp
View File

@@ -20,7 +20,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
template <typename>
@@ -165,7 +165,7 @@ bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn) {
}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

4
wifi/1.5/default/wifi_legacy_hal_stubs.h → wifi/1.6/default/wifi_legacy_hal_stubs.h
View File

@@ -22,14 +22,14 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn);
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

10
wifi/1.5/default/wifi_mode_controller.cpp → wifi/1.6/default/wifi_mode_controller.cpp
View File

@@ -48,15 +48,14 @@ int convertIfaceTypeToFirmwareMode(IfaceType type) {
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
WifiModeController::WifiModeController() : driver_tool_(new DriverTool) {}
bool WifiModeController::isFirmwareModeChangeNeeded(IfaceType type) {
return driver_tool_->IsFirmwareModeChangeNeeded(
convertIfaceTypeToFirmwareMode(type));
return driver_tool_->IsFirmwareModeChangeNeeded(convertIfaceTypeToFirmwareMode(type));
}
bool WifiModeController::initialize() {
@@ -68,8 +67,7 @@ bool WifiModeController::initialize() {
}
bool WifiModeController::changeFirmwareMode(IfaceType type) {
if (!driver_tool_->ChangeFirmwareMode(
convertIfaceTypeToFirmwareMode(type))) {
if (!driver_tool_->ChangeFirmwareMode(convertIfaceTypeToFirmwareMode(type))) {
LOG(ERROR) << "Failed to change firmware mode";
return false;
}
@@ -85,7 +83,7 @@ bool WifiModeController::deinitialize() {
}
} // namespace mode_controller
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

8
wifi/1.5/default/wifi_mode_controller.h → wifi/1.6/default/wifi_mode_controller.h
View File

@@ -24,7 +24,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
using namespace android::hardware::wifi::V1_0;
@@ -35,7 +35,7 @@ using namespace android::hardware::wifi::V1_0;
* required state (essentially a wrapper over DriverTool).
*/
class WifiModeController {
public:
public:
WifiModeController();
virtual ~WifiModeController() = default;
@@ -49,13 +49,13 @@ class WifiModeController {
// invoked.
virtual bool deinitialize();
private:
private:
std::unique_ptr<wifi_hal::DriverTool> driver_tool_;
};
} // namespace mode_controller
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

905
wifi/1.6/default/wifi_nan_iface.cpp Normal file
View File

@@ -0,0 +1,905 @@
/*
* 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_nan_iface.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_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) {
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.
invalidate();
return;
}
}
// 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;
android::wp<WifiNanIface> weak_ptr_this(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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
WifiNanStatus wifiNanStatus;
if (!hidl_struct_util::convertLegacyNanResponseHeaderToHidl(msg, &wifiNanStatus)) {
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, wifiNanStatus).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, wifiNanStatus).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, wifiNanStatus,
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, wifiNanStatus).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, wifiNanStatus).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, wifiNanStatus,
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, wifiNanStatus).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, wifiNanStatus).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
break;
}
case legacy_hal::NAN_GET_CAPABILITIES: {
V1_5::NanCapabilities hidl_struct;
if (!hidl_struct_util::convertLegacyNanCapabilitiesResponseToHidl(
msg.body.nan_capabilities, &hidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks_1_5()) {
if (!callback->notifyCapabilitiesResponse_1_5(id, wifiNanStatus, hidl_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, wifiNanStatus).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, wifiNanStatus).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, wifiNanStatus,
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, wifiNanStatus)
.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, wifiNanStatus).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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
NanClusterEventInd hidl_struct;
// event types defined identically - hence can be cast
hidl_struct.eventType = (NanClusterEventType)msg.event_type;
hidl_struct.addr = msg.data.mac_addr.addr;
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventClusterEvent(hidl_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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
WifiNanStatus status;
hidl_struct_util::convertToWifiNanStatus(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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
WifiNanStatus status;
hidl_struct_util::convertToWifiNanStatus(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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
WifiNanStatus status;
hidl_struct_util::convertToWifiNanStatus(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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
NanMatchInd hidl_struct;
if (!hidl_struct_util::convertLegacyNanMatchIndToHidl(msg, &hidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventMatch(hidl_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.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->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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
NanFollowupReceivedInd hidl_struct;
if (!hidl_struct_util::convertLegacyNanFollowupIndToHidl(msg, &hidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventFollowupReceived(hidl_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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
WifiNanStatus status;
hidl_struct_util::convertToWifiNanStatus(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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
NanDataPathRequestInd hidl_struct;
if (!hidl_struct_util::convertLegacyNanDataPathRequestIndToHidl(msg,
&hidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->eventDataPathRequest(hidl_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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
V1_2::NanDataPathConfirmInd hidl_struct;
if (!hidl_struct_util::convertLegacyNanDataPathConfirmIndToHidl(msg,
&hidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks_1_2()) {
if (!callback->eventDataPathConfirm_1_2(hidl_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.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()) {
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 =
[weak_ptr_this](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) {
LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called";
};
callback_handlers.on_event_range_request =
[weak_ptr_this](const legacy_hal::NanRangeRequestInd& /* msg */) {
LOG(ERROR) << "on_event_range_request - should not be called";
};
callback_handlers.on_event_range_report =
[weak_ptr_this](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.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
V1_2::NanDataPathScheduleUpdateInd hidl_struct;
if (!hidl_struct_util::convertLegacyNanDataPathScheduleUpdateIndToHidl(
msg, &hidl_struct)) {
LOG(ERROR) << "Failed to convert nan capabilities response";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks_1_2()) {
if (!callback->eventDataPathScheduleUpdate(hidl_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.promote();
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.
WifiNanStatus status = {NanStatusType::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::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();
event_cb_handler_1_2_.invalidate();
event_cb_handler_1_5_.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<sp<V1_0::IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks() {
return event_cb_handler_.getCallbacks();
}
std::set<sp<V1_2::IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks_1_2() {
return event_cb_handler_1_2_.getCallbacks();
}
std::set<sp<V1_5::IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks_1_5() {
return event_cb_handler_1_5_.getCallbacks();
}
Return<void> WifiNanIface::getName(getName_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::getNameInternal, hidl_status_cb);
}
Return<void> WifiNanIface::getType(getType_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::getTypeInternal, hidl_status_cb);
}
Return<void> WifiNanIface::registerEventCallback(
const sp<V1_0::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::registerEventCallbackInternal, hidl_status_cb, callback);
}
Return<void> WifiNanIface::getCapabilitiesRequest(uint16_t cmd_id,
getCapabilitiesRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::getCapabilitiesRequestInternal, hidl_status_cb, cmd_id);
}
Return<void> WifiNanIface::enableRequest(uint16_t cmd_id, const V1_0::NanEnableRequest& msg,
enableRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::enableRequestInternal, hidl_status_cb, cmd_id, msg);
}
Return<void> WifiNanIface::configRequest(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
configRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::configRequestInternal, hidl_status_cb, cmd_id, msg);
}
Return<void> WifiNanIface::disableRequest(uint16_t cmd_id, disableRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::disableRequestInternal, hidl_status_cb, cmd_id);
}
Return<void> WifiNanIface::startPublishRequest(uint16_t cmd_id, const NanPublishRequest& msg,
startPublishRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::startPublishRequestInternal, hidl_status_cb, cmd_id, msg);
}
Return<void> WifiNanIface::stopPublishRequest(uint16_t cmd_id, uint8_t sessionId,
stopPublishRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::stopPublishRequestInternal, hidl_status_cb, cmd_id,
sessionId);
}
Return<void> WifiNanIface::startSubscribeRequest(uint16_t cmd_id, const NanSubscribeRequest& msg,
startSubscribeRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::startSubscribeRequestInternal, hidl_status_cb, cmd_id,
msg);
}
Return<void> WifiNanIface::stopSubscribeRequest(uint16_t cmd_id, uint8_t sessionId,
stopSubscribeRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::stopSubscribeRequestInternal, hidl_status_cb, cmd_id,
sessionId);
}
Return<void> WifiNanIface::transmitFollowupRequest(uint16_t cmd_id,
const NanTransmitFollowupRequest& msg,
transmitFollowupRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::transmitFollowupRequestInternal, hidl_status_cb, cmd_id,
msg);
}
Return<void> WifiNanIface::createDataInterfaceRequest(
uint16_t cmd_id, const hidl_string& iface_name,
createDataInterfaceRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::createDataInterfaceRequestInternal, hidl_status_cb,
cmd_id, iface_name);
}
Return<void> WifiNanIface::deleteDataInterfaceRequest(
uint16_t cmd_id, const hidl_string& iface_name,
deleteDataInterfaceRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::deleteDataInterfaceRequestInternal, hidl_status_cb,
cmd_id, iface_name);
}
Return<void> WifiNanIface::initiateDataPathRequest(uint16_t cmd_id,
const NanInitiateDataPathRequest& msg,
initiateDataPathRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::initiateDataPathRequestInternal, hidl_status_cb, cmd_id,
msg);
}
Return<void> WifiNanIface::respondToDataPathIndicationRequest(
uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg,
respondToDataPathIndicationRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::respondToDataPathIndicationRequestInternal,
hidl_status_cb, cmd_id, msg);
}
Return<void> WifiNanIface::terminateDataPathRequest(uint16_t cmd_id, uint32_t ndpInstanceId,
terminateDataPathRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::terminateDataPathRequestInternal, hidl_status_cb, cmd_id,
ndpInstanceId);
}
Return<void> WifiNanIface::registerEventCallback_1_2(
const sp<V1_2::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_2_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::registerEventCallback_1_2Internal, hidl_status_cb,
callback);
}
Return<void> WifiNanIface::enableRequest_1_2(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
enableRequest_1_2_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::enableRequest_1_2Internal, hidl_status_cb, cmd_id, msg1,
msg2);
}
Return<void> WifiNanIface::configRequest_1_2(uint16_t cmd_id, const V1_0::NanConfigRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
configRequest_1_2_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::configRequest_1_2Internal, hidl_status_cb, cmd_id, msg1,
msg2);
}
Return<void> WifiNanIface::enableRequest_1_4(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
enableRequest_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::enableRequest_1_4Internal, hidl_status_cb, cmd_id, msg1,
msg2);
}
Return<void> WifiNanIface::configRequest_1_4(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
configRequest_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::configRequest_1_4Internal, hidl_status_cb, cmd_id, msg1,
msg2);
}
Return<void> WifiNanIface::registerEventCallback_1_5(
const sp<V1_5::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::registerEventCallback_1_5Internal, hidl_status_cb,
callback);
}
Return<void> WifiNanIface::enableRequest_1_5(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2,
enableRequest_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::enableRequest_1_5Internal, hidl_status_cb, cmd_id, msg1,
msg2);
}
Return<void> WifiNanIface::configRequest_1_5(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2,
configRequest_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::configRequest_1_5Internal, hidl_status_cb, cmd_id, msg1,
msg2);
}
Return<void> WifiNanIface::getCapabilitiesRequest_1_5(
uint16_t cmd_id, getCapabilitiesRequest_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiNanIface::getCapabilitiesRequest_1_5Internal, hidl_status_cb,
cmd_id);
}
std::pair<WifiStatus, std::string> WifiNanIface::getNameInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
}
std::pair<WifiStatus, IfaceType> WifiNanIface::getTypeInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::NAN};
}
WifiStatus WifiNanIface::registerEventCallbackInternal(
const sp<V1_0::IWifiNanIfaceEventCallback>& callback) {
if (!event_cb_handler_.addCallback(callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus WifiNanIface::getCapabilitiesRequestInternal(uint16_t /* cmd_id */) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiNanIface::enableRequestInternal(uint16_t /* cmd_id */,
const V1_0::NanEnableRequest& /* msg */) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiNanIface::configRequestInternal(uint16_t /* cmd_id */,
const V1_0::NanConfigRequest& /* msg */) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiNanIface::disableRequestInternal(uint16_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiNanIface::startPublishRequestInternal(uint16_t cmd_id,
const NanPublishRequest& msg) {
legacy_hal::NanPublishRequest legacy_msg;
if (!hidl_struct_util::convertHidlNanPublishRequestToLegacy(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);
}
WifiStatus WifiNanIface::stopPublishRequestInternal(uint16_t cmd_id, uint8_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);
}
WifiStatus WifiNanIface::startSubscribeRequestInternal(uint16_t cmd_id,
const NanSubscribeRequest& msg) {
legacy_hal::NanSubscribeRequest legacy_msg;
if (!hidl_struct_util::convertHidlNanSubscribeRequestToLegacy(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);
}
WifiStatus WifiNanIface::stopSubscribeRequestInternal(uint16_t cmd_id, uint8_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);
}
WifiStatus WifiNanIface::transmitFollowupRequestInternal(uint16_t cmd_id,
const NanTransmitFollowupRequest& msg) {
legacy_hal::NanTransmitFollowupRequest legacy_msg;
if (!hidl_struct_util::convertHidlNanTransmitFollowupRequestToLegacy(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);
}
WifiStatus WifiNanIface::createDataInterfaceRequestInternal(uint16_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);
}
WifiStatus WifiNanIface::deleteDataInterfaceRequestInternal(uint16_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);
}
WifiStatus WifiNanIface::initiateDataPathRequestInternal(uint16_t cmd_id,
const NanInitiateDataPathRequest& msg) {
legacy_hal::NanDataPathInitiatorRequest legacy_msg;
if (!hidl_struct_util::convertHidlNanDataPathInitiatorRequestToLegacy(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);
}
WifiStatus WifiNanIface::respondToDataPathIndicationRequestInternal(
uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) {
legacy_hal::NanDataPathIndicationResponse legacy_msg;
if (!hidl_struct_util::convertHidlNanDataPathIndicationResponseToLegacy(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);
}
WifiStatus WifiNanIface::terminateDataPathRequestInternal(uint16_t cmd_id, uint32_t ndpInstanceId) {
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiNanIface::registerEventCallback_1_2Internal(
const sp<V1_2::IWifiNanIfaceEventCallback>& callback) {
sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback;
if (!event_cb_handler_.addCallback(callback_1_0)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
if (!event_cb_handler_1_2_.addCallback(callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus WifiNanIface::enableRequest_1_2Internal(
uint16_t /* cmd_id */, const V1_0::NanEnableRequest& /* msg1 */,
const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiNanIface::configRequest_1_2Internal(
uint16_t /* cmd_id */, const V1_0::NanConfigRequest& /* msg1 */,
const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiNanIface::enableRequest_1_4Internal(
uint16_t /* cmd_id */, const V1_4::NanEnableRequest& /* msg1 */,
const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiNanIface::configRequest_1_4Internal(
uint16_t /* cmd_id */, const V1_4::NanConfigRequest& /* msg1 */,
const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiNanIface::registerEventCallback_1_5Internal(
const sp<V1_5::IWifiNanIfaceEventCallback>& callback) {
sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback;
if (!event_cb_handler_.addCallback(callback_1_0)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
sp<V1_2::IWifiNanIfaceEventCallback> callback_1_2 = callback;
if (!event_cb_handler_1_2_.addCallback(callback_1_2)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
if (!event_cb_handler_1_5_.addCallback(callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus WifiNanIface::getCapabilitiesRequest_1_5Internal(uint16_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiNanIface::enableRequest_1_5Internal(uint16_t cmd_id,
const V1_4::NanEnableRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2) {
legacy_hal::NanEnableRequest legacy_msg;
if (!hidl_struct_util::convertHidlNanEnableRequest_1_5ToLegacy(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);
}
WifiStatus WifiNanIface::configRequest_1_5Internal(uint16_t cmd_id,
const V1_4::NanConfigRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2) {
legacy_hal::NanConfigRequest legacy_msg;
if (!hidl_struct_util::convertHidlNanConfigRequest_1_5ToLegacy(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);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

174
wifi/1.6/default/wifi_nan_iface.h Normal file
View File

@@ -0,0 +1,174 @@
/*
* 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.5/IWifiNanIface.h>
#include <android/hardware/wifi/1.5/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;
/**
* HIDL interface object used to control a NAN Iface instance.
*/
class WifiNanIface : public V1_5::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 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 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 NanInitiateDataPathRequest& msg,
initiateDataPathRequest_cb hidl_status_cb) override;
Return<void> respondToDataPathIndicationRequest(
uint16_t cmd_id, const 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_4_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_4_cb hidl_status_cb) override;
Return<void> getCapabilitiesRequest_1_5(uint16_t cmd_id,
getCapabilitiesRequest_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 NanPublishRequest& msg);
WifiStatus stopPublishRequestInternal(uint16_t cmd_id, uint8_t sessionId);
WifiStatus startSubscribeRequestInternal(uint16_t cmd_id, const 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 NanInitiateDataPathRequest& msg);
WifiStatus respondToDataPathIndicationRequestInternal(
uint16_t cmd_id, const 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);
// 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();
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_;
DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_NAN_IFACE_H_

17
wifi/1.5/default/wifi_p2p_iface.cpp → wifi/1.6/default/wifi_p2p_iface.cpp
View File

@@ -23,13 +23,12 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
WifiP2pIface::WifiP2pIface(
const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
WifiP2pIface::WifiP2pIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {}
void WifiP2pIface::invalidate() {
@@ -37,9 +36,13 @@ void WifiP2pIface::invalidate() {
is_valid_ = false;
}
bool WifiP2pIface::isValid() { return is_valid_; }
bool WifiP2pIface::isValid() {
return is_valid_;
}
std::string WifiP2pIface::getName() { return ifname_; }
std::string WifiP2pIface::getName() {
return ifname_;
}
Return<void> WifiP2pIface::getName(getName_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
@@ -60,7 +63,7 @@ std::pair<WifiStatus, IfaceType> WifiP2pIface::getTypeInternal() {
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

8
wifi/1.5/default/wifi_p2p_iface.h → wifi/1.6/default/wifi_p2p_iface.h
View File

@@ -25,7 +25,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
@@ -33,7 +33,7 @@ using namespace android::hardware::wifi::V1_0;
* HIDL interface object used to control a P2P Iface instance.
*/
class WifiP2pIface : public V1_0::IWifiP2pIface {
public:
public:
WifiP2pIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
// Refer to |WifiChip::invalidate()|.
@@ -45,7 +45,7 @@ class WifiP2pIface : public V1_0::IWifiP2pIface {
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
private:
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
@@ -58,7 +58,7 @@ class WifiP2pIface : public V1_0::IWifiP2pIface {
};
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

311
wifi/1.6/default/wifi_rtt_controller.cpp Normal file
View File

@@ -0,0 +1,311 @@
/*
* 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_4::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 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 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);
}
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 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) {
// TODO(b/31632518): remove the callback when the client is destroyed
event_callbacks_.emplace_back(callback);
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus WifiRttController::rangeRequestInternal_1_4(
uint32_t cmd_id, const std::vector<V1_4::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_4::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()) {
callback->onResults_1_4(id, hidl_results);
}
};
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_4::RttCapabilities> WifiRttController::getCapabilitiesInternal_1_4() {
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_4::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_4::RttResponder> WifiRttController::getResponderInfoInternal_1_4() {
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_4::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_4(uint32_t cmd_id,
const WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_4::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

75
wifi/1.5/default/wifi_rtt_controller.h → wifi/1.6/default/wifi_rtt_controller.h
View File

@@ -27,17 +27,16 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
/**
* HIDL interface object used to control all RTT operations.
*/
class WifiRttController : public V1_4::IWifiRttController {
public:
WifiRttController(
const std::string& iface_name, const sp<IWifiIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
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();
@@ -46,14 +45,11 @@ class WifiRttController : public V1_4::IWifiRttController {
// 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,
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,
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,
@@ -61,54 +57,45 @@ class WifiRttController : public V1_4::IWifiRttController {
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 WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_0::RttResponder& info,
Return<void> enableResponder(uint32_t cmd_id, const 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> 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,
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 WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_4::RttResponder& info,
enableResponder_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 WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_4::RttResponder& info,
enableResponder_1_4_cb hidl_status_cb) override;
private:
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);
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 WifiChannelInfo& channel_hint,
WifiStatus enableResponderInternal(uint32_t cmd_id, const 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);
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 WifiChannelInfo& channel_hint,
WifiStatus enableResponderInternal_1_4(uint32_t cmd_id, const WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_4::RttResponder& info);
@@ -122,7 +109,7 @@ class WifiRttController : public V1_4::IWifiRttController {
};
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

490
wifi/1.5/default/wifi_sta_iface.cpp → wifi/1.6/default/wifi_sta_iface.cpp
View File

@@ -24,24 +24,18 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
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) {
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);
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.";
LOG(ERROR) << "Failed to set DFS flag; DFS channels may be unavailable.";
}
}
@@ -51,9 +45,13 @@ void WifiStaIface::invalidate() {
is_valid_ = false;
}
bool WifiStaIface::isValid() { return is_valid_; }
bool WifiStaIface::isValid() {
return is_valid_;
}
std::string WifiStaIface::getName() { return ifname_; }
std::string WifiStaIface::getName() {
return ifname_;
}
std::set<sp<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() {
return event_cb_handler_.getCallbacks();
@@ -69,215 +67,177 @@ Return<void> WifiStaIface::getType(getType_cb hidl_status_cb) {
&WifiStaIface::getTypeInternal, hidl_status_cb);
}
Return<void> WifiStaIface::registerEventCallback(
const sp<IWifiStaIfaceEventCallback>& callback,
registerEventCallback_cb 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);
&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);
&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);
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<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);
&WifiStaIface::installApfPacketFilterInternal, hidl_status_cb, cmd_id,
program);
}
Return<void> WifiStaIface::readApfPacketFilterData(
readApfPacketFilterData_cb hidl_status_cb) {
Return<void> WifiStaIface::readApfPacketFilterData(readApfPacketFilterData_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::readApfPacketFilterDataInternal,
hidl_status_cb);
&WifiStaIface::readApfPacketFilterDataInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getBackgroundScanCapabilities(
getBackgroundScanCapabilities_cb hidl_status_cb) {
getBackgroundScanCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getBackgroundScanCapabilitiesInternal,
hidl_status_cb);
&WifiStaIface::getBackgroundScanCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getValidFrequenciesForBand(
V1_0::WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) {
V1_0::WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getValidFrequenciesForBandInternal,
hidl_status_cb, band);
&WifiStaIface::getValidFrequenciesForBandInternal, hidl_status_cb, band);
}
Return<void> WifiStaIface::startBackgroundScan(
uint32_t cmd_id, const StaBackgroundScanParameters& params,
startBackgroundScan_cb hidl_status_cb) {
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);
&WifiStaIface::startBackgroundScanInternal, hidl_status_cb, cmd_id,
params);
}
Return<void> WifiStaIface::stopBackgroundScan(
uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) {
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);
&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);
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);
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<void> WifiStaIface::getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getLinkLayerStatsInternal,
hidl_status_cb);
&WifiStaIface::getLinkLayerStatsInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getLinkLayerStats_1_3(
getLinkLayerStats_1_3_cb 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);
&WifiStaIface::getLinkLayerStatsInternal_1_3, hidl_status_cb);
}
Return<void> WifiStaIface::getLinkLayerStats_1_5(
getLinkLayerStats_1_5_cb 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);
&WifiStaIface::getLinkLayerStatsInternal_1_5, 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<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);
&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<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);
&WifiStaIface::stopRssiMonitoringInternal, hidl_status_cb, cmd_id);
}
Return<void> WifiStaIface::getRoamingCapabilities(
getRoamingCapabilities_cb hidl_status_cb) {
Return<void> WifiStaIface::getRoamingCapabilities(getRoamingCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getRoamingCapabilitiesInternal,
hidl_status_cb);
&WifiStaIface::getRoamingCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::configureRoaming(
const StaRoamingConfig& config, configureRoaming_cb 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);
&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);
&WifiStaIface::setRoamingStateInternal, hidl_status_cb, state);
}
Return<void> WifiStaIface::enableNdOffload(bool enable,
enableNdOffload_cb hidl_status_cb) {
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);
&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) {
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);
&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) {
uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::stopSendingKeepAlivePacketsInternal,
hidl_status_cb, cmd_id);
&WifiStaIface::stopSendingKeepAlivePacketsInternal, hidl_status_cb,
cmd_id);
}
Return<void> WifiStaIface::setScanningMacOui(
const hidl_array<uint8_t, 3>& oui, setScanningMacOui_cb hidl_status_cb) {
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);
&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);
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<void> WifiStaIface::getDebugTxPacketFates(getDebugTxPacketFates_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getDebugTxPacketFatesInternal,
hidl_status_cb);
&WifiStaIface::getDebugTxPacketFatesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getDebugRxPacketFates(
getDebugRxPacketFates_cb 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);
&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);
&WifiStaIface::setMacAddressInternal, hidl_status_cb, mac);
}
Return<void> WifiStaIface::getFactoryMacAddress(
getFactoryMacAddress_cb hidl_status_cb) {
Return<void> WifiStaIface::getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getFactoryMacAddressInternal,
hidl_status_cb);
&WifiStaIface::getFactoryMacAddressInternal, hidl_status_cb);
}
Return<void> WifiStaIface::setScanMode(bool enable,
setScanMode_cb 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);
&WifiStaIface::setScanModeInternal, hidl_status_cb, enable);
}
std::pair<WifiStatus, std::string> WifiStaIface::getNameInternal() {
@@ -289,7 +249,7 @@ std::pair<WifiStatus, IfaceType> WifiStaIface::getTypeInternal() {
}
WifiStatus WifiStaIface::registerEventCallbackInternal(
const sp<IWifiStaIfaceEventCallback>& callback) {
const sp<IWifiStaIfaceEventCallback>& callback) {
if (!event_cb_handler_.addCallback(callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
@@ -300,20 +260,20 @@ 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_);
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_);
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)) {
legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
@@ -323,30 +283,25 @@ 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_);
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)) {
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);
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 =
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)};
@@ -356,14 +311,12 @@ 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_);
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)) {
if (!hidl_struct_util::convertLegacyGscanCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
@@ -371,240 +324,201 @@ WifiStaIface::getBackgroundScanCapabilitiesInternal() {
std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
WifiStaIface::getValidFrequenciesForBandInternal(V1_0::WifiBand band) {
static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t),
"Size mismatch");
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(
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) {
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)) {
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;
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";
}
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";
[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) {
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)) {
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";
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);
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);
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);
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_);
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableLinkLayerStats(ifname_);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_0::StaLinkLayerStats>
WifiStaIface::getLinkLayerStatsInternal() {
std::pair<WifiStatus, V1_0::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal() {
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_3::StaLinkLayerStats>
WifiStaIface::getLinkLayerStatsInternal_1_3() {
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() {
std::pair<WifiStatus, V1_5::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_5() {
legacy_hal::wifi_error legacy_status;
legacy_hal::LinkLayerStats legacy_stats;
std::tie(legacy_status, legacy_stats) =
legacy_hal_.lock()->getLinkLayerStats(ifname_);
std::tie(legacy_status, legacy_stats) = legacy_hal_.lock()->getLinkLayerStats(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
V1_5::StaLinkLayerStats hidl_stats;
if (!hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats,
&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,
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;
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";
}
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);
}
};
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);
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopRssiMonitoring(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, StaRoamingCapabilities>
WifiStaIface::getRoamingCapabilitiesInternal() {
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_);
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)) {
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) {
WifiStatus WifiStaIface::configureRoamingInternal(const StaRoamingConfig& config) {
legacy_hal::wifi_roaming_config legacy_config;
if (!hidl_struct_util::convertHidlRoamingConfigToLegacy(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);
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(
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);
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);
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);
legacy_hal_.lock()->stopSendingOffloadedPacket(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::setScanningMacOuiInternal(
const std::array<uint8_t, 3>& /* oui */) {
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_);
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startPktFateMonitoring(ifname_);
return createWifiStatusFromLegacyError(legacy_status);
}
@@ -612,14 +526,13 @@ 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_);
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)) {
if (!hidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToHidl(legacy_fates,
&hidl_fates)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
@@ -629,21 +542,19 @@ 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_);
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)) {
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) {
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);
@@ -651,12 +562,9 @@ WifiStatus WifiStaIface::setMacAddressInternal(
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) {
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};
@@ -669,7 +577,7 @@ WifiStatus WifiStaIface::setScanModeInternal(bool enable) {
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

155
wifi/1.6/default/wifi_sta_iface.h Normal file
View File

@@ -0,0 +1,155 @@
/*
* 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.5/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_5::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> 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();
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_

22
wifi/1.5/default/wifi_status_util.cpp → wifi/1.6/default/wifi_status_util.cpp
View File

@@ -19,7 +19,7 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
std::string legacyErrorToString(legacy_hal::wifi_error error) {
@@ -51,8 +51,7 @@ std::string legacyErrorToString(legacy_hal::wifi_error error) {
}
}
WifiStatus createWifiStatus(WifiStatusCode code,
const std::string& description) {
WifiStatus createWifiStatus(WifiStatusCode code, const std::string& description) {
return {code, description};
}
@@ -60,8 +59,7 @@ WifiStatus createWifiStatus(WifiStatusCode code) {
return createWifiStatus(code, "");
}
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
const std::string& desc) {
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error, const std::string& desc) {
switch (error) {
case legacy_hal::WIFI_ERROR_UNINITIALIZED:
case legacy_hal::WIFI_ERROR_NOT_AVAILABLE:
@@ -75,16 +73,13 @@ WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS, desc);
case legacy_hal::WIFI_ERROR_TIMED_OUT:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
desc + ", timed out");
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, desc + ", timed out");
case legacy_hal::WIFI_ERROR_TOO_MANY_REQUESTS:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
desc + ", too many requests");
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, desc + ", too many requests");
case legacy_hal::WIFI_ERROR_OUT_OF_MEMORY:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
desc + ", out of memory");
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, desc + ", out of memory");
case legacy_hal::WIFI_ERROR_BUSY:
return createWifiStatus(WifiStatusCode::ERROR_BUSY);
@@ -96,8 +91,7 @@ WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown");
default:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
"unknown error");
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown error");
}
}
@@ -106,7 +100,7 @@ WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error) {
}
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

7
wifi/1.5/default/wifi_status_util.h → wifi/1.6/default/wifi_status_util.h
View File

@@ -24,20 +24,19 @@
namespace android {
namespace hardware {
namespace wifi {
namespace V1_5 {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
std::string legacyErrorToString(legacy_hal::wifi_error error);
WifiStatus createWifiStatus(WifiStatusCode code,
const std::string& description);
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);
} // namespace implementation
} // namespace V1_5
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android