blob: 800813f1667d5f12818195bd410f15a6ffe9132c [file] [log] [blame]
Gabriel Birenf3262f92022-07-15 23:25:39 +00001/*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "wifi_sta_iface.h"
18
19#include <android-base/logging.h>
20
21#include "aidl_return_util.h"
22#include "aidl_struct_util.h"
23#include "wifi_status_util.h"
24
25namespace aidl {
26namespace android {
27namespace hardware {
28namespace wifi {
29using aidl_return_util::validateAndCall;
30
31WifiStaIface::WifiStaIface(const std::string& ifname,
32 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
33 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
34 : ifname_(ifname), legacy_hal_(legacy_hal), iface_util_(iface_util), is_valid_(true) {
35 // Turn on DFS channel usage for STA iface.
36 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setDfsFlag(ifname_, true);
37 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
38 LOG(ERROR) << "Failed to set DFS flag; DFS channels may be unavailable.";
39 }
40}
41
42std::shared_ptr<WifiStaIface> WifiStaIface::create(
43 const std::string& ifname, const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
44 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) {
45 std::shared_ptr<WifiStaIface> ptr =
46 ndk::SharedRefBase::make<WifiStaIface>(ifname, legacy_hal, iface_util);
47 std::weak_ptr<WifiStaIface> weak_ptr_this(ptr);
48 ptr->setWeakPtr(weak_ptr_this);
49 return ptr;
50}
51
52void WifiStaIface::invalidate() {
53 legacy_hal_.reset();
54 event_cb_handler_.invalidate();
55 is_valid_ = false;
56}
57
58void WifiStaIface::setWeakPtr(std::weak_ptr<WifiStaIface> ptr) {
59 weak_ptr_this_ = ptr;
60}
61
62bool WifiStaIface::isValid() {
63 return is_valid_;
64}
65
66std::string WifiStaIface::getName() {
67 return ifname_;
68}
69
70std::set<std::shared_ptr<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() {
71 return event_cb_handler_.getCallbacks();
72}
73
74ndk::ScopedAStatus WifiStaIface::getName(std::string* _aidl_return) {
75 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
76 &WifiStaIface::getNameInternal, _aidl_return);
77}
78
79ndk::ScopedAStatus WifiStaIface::registerEventCallback(
80 const std::shared_ptr<IWifiStaIfaceEventCallback>& in_callback) {
81 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
82 &WifiStaIface::registerEventCallbackInternal, in_callback);
83}
84
Gabriel Biren2f862492023-03-09 19:13:07 +000085ndk::ScopedAStatus WifiStaIface::getFeatureSet(int32_t* _aidl_return) {
Gabriel Birenf3262f92022-07-15 23:25:39 +000086 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
Gabriel Biren2f862492023-03-09 19:13:07 +000087 &WifiStaIface::getFeatureSetInternal, _aidl_return);
Gabriel Birenf3262f92022-07-15 23:25:39 +000088}
89
90ndk::ScopedAStatus WifiStaIface::getApfPacketFilterCapabilities(
91 StaApfPacketFilterCapabilities* _aidl_return) {
92 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
93 &WifiStaIface::getApfPacketFilterCapabilitiesInternal, _aidl_return);
94}
95
96ndk::ScopedAStatus WifiStaIface::installApfPacketFilter(const std::vector<uint8_t>& in_program) {
97 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
98 &WifiStaIface::installApfPacketFilterInternal, in_program);
99}
100
101ndk::ScopedAStatus WifiStaIface::readApfPacketFilterData(std::vector<uint8_t>* _aidl_return) {
102 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
103 &WifiStaIface::readApfPacketFilterDataInternal, _aidl_return);
104}
105
106ndk::ScopedAStatus WifiStaIface::getBackgroundScanCapabilities(
107 StaBackgroundScanCapabilities* _aidl_return) {
108 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
109 &WifiStaIface::getBackgroundScanCapabilitiesInternal, _aidl_return);
110}
111
Gabriel Birenf3262f92022-07-15 23:25:39 +0000112ndk::ScopedAStatus WifiStaIface::startBackgroundScan(int32_t in_cmdId,
113 const StaBackgroundScanParameters& in_params) {
114 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
115 &WifiStaIface::startBackgroundScanInternal, in_cmdId, in_params);
116}
117
118ndk::ScopedAStatus WifiStaIface::stopBackgroundScan(int32_t in_cmdId) {
119 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
120 &WifiStaIface::stopBackgroundScanInternal, in_cmdId);
121}
122
123ndk::ScopedAStatus WifiStaIface::enableLinkLayerStatsCollection(bool in_debug) {
124 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
125 &WifiStaIface::enableLinkLayerStatsCollectionInternal, in_debug);
126}
127
128ndk::ScopedAStatus WifiStaIface::disableLinkLayerStatsCollection() {
129 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
130 &WifiStaIface::disableLinkLayerStatsCollectionInternal);
131}
132
133ndk::ScopedAStatus WifiStaIface::getLinkLayerStats(StaLinkLayerStats* _aidl_return) {
134 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
135 &WifiStaIface::getLinkLayerStatsInternal, _aidl_return);
136}
137
138ndk::ScopedAStatus WifiStaIface::startRssiMonitoring(int32_t in_cmdId, int32_t in_maxRssi,
139 int32_t in_minRssi) {
140 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
141 &WifiStaIface::startRssiMonitoringInternal, in_cmdId, in_maxRssi,
142 in_minRssi);
143}
144
145ndk::ScopedAStatus WifiStaIface::stopRssiMonitoring(int32_t in_cmdId) {
146 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
147 &WifiStaIface::stopRssiMonitoringInternal, in_cmdId);
148}
149
150ndk::ScopedAStatus WifiStaIface::getRoamingCapabilities(StaRoamingCapabilities* _aidl_return) {
151 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
152 &WifiStaIface::getRoamingCapabilitiesInternal, _aidl_return);
153}
154
155ndk::ScopedAStatus WifiStaIface::configureRoaming(const StaRoamingConfig& in_config) {
156 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
157 &WifiStaIface::configureRoamingInternal, in_config);
158}
159
160ndk::ScopedAStatus WifiStaIface::setRoamingState(StaRoamingState in_state) {
161 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
162 &WifiStaIface::setRoamingStateInternal, in_state);
163}
164
165ndk::ScopedAStatus WifiStaIface::enableNdOffload(bool in_enable) {
166 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
167 &WifiStaIface::enableNdOffloadInternal, in_enable);
168}
169
170ndk::ScopedAStatus WifiStaIface::startSendingKeepAlivePackets(
171 int32_t in_cmdId, const std::vector<uint8_t>& in_ipPacketData, char16_t in_etherType,
172 const std::array<uint8_t, 6>& in_srcAddress, const std::array<uint8_t, 6>& in_dstAddress,
173 int32_t in_periodInMs) {
174 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
175 &WifiStaIface::startSendingKeepAlivePacketsInternal, in_cmdId,
176 in_ipPacketData, in_etherType, in_srcAddress, in_dstAddress,
177 in_periodInMs);
178}
179
180ndk::ScopedAStatus WifiStaIface::stopSendingKeepAlivePackets(int32_t in_cmdId) {
181 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
182 &WifiStaIface::stopSendingKeepAlivePacketsInternal, in_cmdId);
183}
184
185ndk::ScopedAStatus WifiStaIface::startDebugPacketFateMonitoring() {
186 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
187 &WifiStaIface::startDebugPacketFateMonitoringInternal);
188}
189
190ndk::ScopedAStatus WifiStaIface::getDebugTxPacketFates(
191 std::vector<WifiDebugTxPacketFateReport>* _aidl_return) {
192 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
193 &WifiStaIface::getDebugTxPacketFatesInternal, _aidl_return);
194}
195
196ndk::ScopedAStatus WifiStaIface::getDebugRxPacketFates(
197 std::vector<WifiDebugRxPacketFateReport>* _aidl_return) {
198 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
199 &WifiStaIface::getDebugRxPacketFatesInternal, _aidl_return);
200}
201
202ndk::ScopedAStatus WifiStaIface::setMacAddress(const std::array<uint8_t, 6>& in_mac) {
203 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
204 &WifiStaIface::setMacAddressInternal, in_mac);
205}
206
207ndk::ScopedAStatus WifiStaIface::getFactoryMacAddress(std::array<uint8_t, 6>* _aidl_return) {
208 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
209 &WifiStaIface::getFactoryMacAddressInternal, _aidl_return);
210}
211
212ndk::ScopedAStatus WifiStaIface::setScanMode(bool in_enable) {
213 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
214 &WifiStaIface::setScanModeInternal, in_enable);
215}
216
Kai Shi6d02d402022-11-17 16:34:05 -0800217ndk::ScopedAStatus WifiStaIface::setDtimMultiplier(int32_t in_multiplier) {
218 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
219 &WifiStaIface::setDtimMultiplierInternal, in_multiplier);
220}
221
Gabriel Birenf3262f92022-07-15 23:25:39 +0000222std::pair<std::string, ndk::ScopedAStatus> WifiStaIface::getNameInternal() {
223 return {ifname_, ndk::ScopedAStatus::ok()};
224}
225
226ndk::ScopedAStatus WifiStaIface::registerEventCallbackInternal(
227 const std::shared_ptr<IWifiStaIfaceEventCallback>& callback) {
228 if (!event_cb_handler_.addCallback(callback)) {
229 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
230 }
231 return ndk::ScopedAStatus::ok();
232}
233
Gabriel Biren2f862492023-03-09 19:13:07 +0000234std::pair<int32_t, ndk::ScopedAStatus> WifiStaIface::getFeatureSetInternal() {
Gabriel Birenf3262f92022-07-15 23:25:39 +0000235 legacy_hal::wifi_error legacy_status;
236 uint64_t legacy_feature_set;
237 std::tie(legacy_status, legacy_feature_set) =
238 legacy_hal_.lock()->getSupportedFeatureSet(ifname_);
239 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
Gabriel Biren3b86a782023-02-04 00:42:53 +0000240 return {0, createWifiStatusFromLegacyError(legacy_status)};
Gabriel Birenf3262f92022-07-15 23:25:39 +0000241 }
Gabriel Biren2f862492023-03-09 19:13:07 +0000242 uint32_t aidl_feature_set;
243 if (!aidl_struct_util::convertLegacyStaIfaceFeaturesToAidl(legacy_feature_set,
244 &aidl_feature_set)) {
Gabriel Biren3b86a782023-02-04 00:42:53 +0000245 return {0, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
Gabriel Birenf3262f92022-07-15 23:25:39 +0000246 }
Gabriel Biren2f862492023-03-09 19:13:07 +0000247 return {aidl_feature_set, ndk::ScopedAStatus::ok()};
Gabriel Birenf3262f92022-07-15 23:25:39 +0000248}
249
250std::pair<StaApfPacketFilterCapabilities, ndk::ScopedAStatus>
251WifiStaIface::getApfPacketFilterCapabilitiesInternal() {
252 legacy_hal::wifi_error legacy_status;
253 legacy_hal::PacketFilterCapabilities legacy_caps;
254 std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getPacketFilterCapabilities(ifname_);
255 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
256 return {StaApfPacketFilterCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
257 }
258 StaApfPacketFilterCapabilities aidl_caps;
259 if (!aidl_struct_util::convertLegacyApfCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
260 return {StaApfPacketFilterCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
261 }
262 return {aidl_caps, ndk::ScopedAStatus::ok()};
263}
264
265ndk::ScopedAStatus WifiStaIface::installApfPacketFilterInternal(
266 const std::vector<uint8_t>& program) {
267 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setPacketFilter(ifname_, program);
268 return createWifiStatusFromLegacyError(legacy_status);
269}
270
271std::pair<std::vector<uint8_t>, ndk::ScopedAStatus>
272WifiStaIface::readApfPacketFilterDataInternal() {
273 const std::pair<legacy_hal::wifi_error, std::vector<uint8_t>> legacy_status_and_data =
274 legacy_hal_.lock()->readApfPacketFilterData(ifname_);
275 return {std::move(legacy_status_and_data.second),
276 createWifiStatusFromLegacyError(legacy_status_and_data.first)};
277}
278
279std::pair<StaBackgroundScanCapabilities, ndk::ScopedAStatus>
280WifiStaIface::getBackgroundScanCapabilitiesInternal() {
281 legacy_hal::wifi_error legacy_status;
282 legacy_hal::wifi_gscan_capabilities legacy_caps;
283 std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getGscanCapabilities(ifname_);
284 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
285 return {StaBackgroundScanCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
286 }
287 StaBackgroundScanCapabilities aidl_caps;
288 if (!aidl_struct_util::convertLegacyGscanCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
289 return {StaBackgroundScanCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
290 }
291 return {aidl_caps, ndk::ScopedAStatus::ok()};
292}
293
Gabriel Birenf3262f92022-07-15 23:25:39 +0000294ndk::ScopedAStatus WifiStaIface::startBackgroundScanInternal(
295 int32_t cmd_id, const StaBackgroundScanParameters& params) {
296 legacy_hal::wifi_scan_cmd_params legacy_params;
297 if (!aidl_struct_util::convertAidlGscanParamsToLegacy(params, &legacy_params)) {
298 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
299 }
300 std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_;
301 const auto& on_failure_callback = [weak_ptr_this](legacy_hal::wifi_request_id id) {
302 const auto shared_ptr_this = weak_ptr_this.lock();
303 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
304 LOG(ERROR) << "Callback invoked on an invalid object";
305 return;
306 }
307 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
308 if (!callback->onBackgroundScanFailure(id).isOk()) {
309 LOG(ERROR) << "Failed to invoke onBackgroundScanFailure callback";
310 }
311 }
312 };
313 const auto& on_results_callback =
314 [weak_ptr_this](legacy_hal::wifi_request_id id,
315 const std::vector<legacy_hal::wifi_cached_scan_results>& results) {
316 const auto shared_ptr_this = weak_ptr_this.lock();
317 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
318 LOG(ERROR) << "Callback invoked on an invalid object";
319 return;
320 }
321 std::vector<StaScanData> aidl_scan_datas;
322 if (!aidl_struct_util::convertLegacyVectorOfCachedGscanResultsToAidl(
323 results, &aidl_scan_datas)) {
324 LOG(ERROR) << "Failed to convert scan results to AIDL structs";
325 return;
326 }
327 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
328 if (!callback->onBackgroundScanResults(id, aidl_scan_datas).isOk()) {
329 LOG(ERROR) << "Failed to invoke onBackgroundScanResults callback";
330 }
331 }
332 };
333 const auto& on_full_result_callback = [weak_ptr_this](
334 legacy_hal::wifi_request_id id,
335 const legacy_hal::wifi_scan_result* result,
336 uint32_t buckets_scanned) {
337 const auto shared_ptr_this = weak_ptr_this.lock();
338 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
339 LOG(ERROR) << "Callback invoked on an invalid object";
340 return;
341 }
342 StaScanResult aidl_scan_result;
343 if (!aidl_struct_util::convertLegacyGscanResultToAidl(*result, true, &aidl_scan_result)) {
344 LOG(ERROR) << "Failed to convert full scan results to AIDL structs";
345 return;
346 }
347 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
348 if (!callback->onBackgroundFullScanResult(id, buckets_scanned, aidl_scan_result)
349 .isOk()) {
350 LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback";
351 }
352 }
353 };
354 legacy_hal::wifi_error legacy_status =
355 legacy_hal_.lock()->startGscan(ifname_, cmd_id, legacy_params, on_failure_callback,
356 on_results_callback, on_full_result_callback);
357 return createWifiStatusFromLegacyError(legacy_status);
358}
359
360ndk::ScopedAStatus WifiStaIface::stopBackgroundScanInternal(int32_t cmd_id) {
361 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopGscan(ifname_, cmd_id);
362 return createWifiStatusFromLegacyError(legacy_status);
363}
364
365ndk::ScopedAStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) {
366 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableLinkLayerStats(ifname_, debug);
367 return createWifiStatusFromLegacyError(legacy_status);
368}
369
370ndk::ScopedAStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
371 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableLinkLayerStats(ifname_);
372 return createWifiStatusFromLegacyError(legacy_status);
373}
374
375std::pair<StaLinkLayerStats, ndk::ScopedAStatus> WifiStaIface::getLinkLayerStatsInternal() {
376 legacy_hal::wifi_error legacy_status;
Mahesh KKV5f30d332022-10-26 14:07:44 -0700377 legacy_hal::LinkLayerStats legacy_stats{};
378 legacy_hal::LinkLayerMlStats legacy_ml_stats{};
379 legacy_status = legacy_hal_.lock()->getLinkLayerStats(ifname_, legacy_stats, legacy_ml_stats);
Gabriel Birenf3262f92022-07-15 23:25:39 +0000380 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
381 return {StaLinkLayerStats{}, createWifiStatusFromLegacyError(legacy_status)};
382 }
383 StaLinkLayerStats aidl_stats;
Mahesh KKV5f30d332022-10-26 14:07:44 -0700384 if (legacy_stats.valid) {
385 if (!aidl_struct_util::convertLegacyLinkLayerStatsToAidl(legacy_stats, &aidl_stats)) {
386 return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
387 }
388 } else if (legacy_ml_stats.valid) {
389 if (!aidl_struct_util::convertLegacyLinkLayerMlStatsToAidl(legacy_ml_stats, &aidl_stats)) {
390 return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
391 }
392 } else {
Gabriel Birenf3262f92022-07-15 23:25:39 +0000393 return {StaLinkLayerStats{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
394 }
395 return {aidl_stats, ndk::ScopedAStatus::ok()};
396}
397
398ndk::ScopedAStatus WifiStaIface::startRssiMonitoringInternal(int32_t cmd_id, int32_t max_rssi,
399 int32_t min_rssi) {
400 std::weak_ptr<WifiStaIface> weak_ptr_this = weak_ptr_this_;
401 const auto& on_threshold_breached_callback =
402 [weak_ptr_this](legacy_hal::wifi_request_id id, std::array<uint8_t, ETH_ALEN> bssid,
403 int8_t rssi) {
404 const auto shared_ptr_this = weak_ptr_this.lock();
405 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
406 LOG(ERROR) << "Callback invoked on an invalid object";
407 return;
408 }
409 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
410 if (!callback->onRssiThresholdBreached(id, bssid, rssi).isOk()) {
411 LOG(ERROR) << "Failed to invoke onRssiThresholdBreached callback";
412 }
413 }
414 };
415 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRssiMonitoring(
416 ifname_, cmd_id, max_rssi, min_rssi, on_threshold_breached_callback);
417 return createWifiStatusFromLegacyError(legacy_status);
418}
419
420ndk::ScopedAStatus WifiStaIface::stopRssiMonitoringInternal(int32_t cmd_id) {
421 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopRssiMonitoring(ifname_, cmd_id);
422 return createWifiStatusFromLegacyError(legacy_status);
423}
424
425std::pair<StaRoamingCapabilities, ndk::ScopedAStatus>
426WifiStaIface::getRoamingCapabilitiesInternal() {
427 legacy_hal::wifi_error legacy_status;
428 legacy_hal::wifi_roaming_capabilities legacy_caps;
429 std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRoamingCapabilities(ifname_);
430 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
431 return {StaRoamingCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
432 }
433 StaRoamingCapabilities aidl_caps;
434 if (!aidl_struct_util::convertLegacyRoamingCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
435 return {StaRoamingCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
436 }
437 return {aidl_caps, ndk::ScopedAStatus::ok()};
438}
439
440ndk::ScopedAStatus WifiStaIface::configureRoamingInternal(const StaRoamingConfig& config) {
441 legacy_hal::wifi_roaming_config legacy_config;
442 if (!aidl_struct_util::convertAidlRoamingConfigToLegacy(config, &legacy_config)) {
443 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
444 }
445 legacy_hal::wifi_error legacy_status =
446 legacy_hal_.lock()->configureRoaming(ifname_, legacy_config);
447 return createWifiStatusFromLegacyError(legacy_status);
448}
449
450ndk::ScopedAStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) {
451 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableFirmwareRoaming(
452 ifname_, aidl_struct_util::convertAidlRoamingStateToLegacy(state));
453 return createWifiStatusFromLegacyError(legacy_status);
454}
455
456ndk::ScopedAStatus WifiStaIface::enableNdOffloadInternal(bool enable) {
457 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->configureNdOffload(ifname_, enable);
458 return createWifiStatusFromLegacyError(legacy_status);
459}
460
461ndk::ScopedAStatus WifiStaIface::startSendingKeepAlivePacketsInternal(
462 int32_t cmd_id, const std::vector<uint8_t>& ip_packet_data, char16_t ether_type,
463 const std::array<uint8_t, 6>& src_address, const std::array<uint8_t, 6>& dst_address,
464 int32_t period_in_ms) {
465 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startSendingOffloadedPacket(
466 ifname_, cmd_id, ether_type, ip_packet_data, src_address, dst_address, period_in_ms);
467 return createWifiStatusFromLegacyError(legacy_status);
468}
469
470ndk::ScopedAStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(int32_t cmd_id) {
471 legacy_hal::wifi_error legacy_status =
472 legacy_hal_.lock()->stopSendingOffloadedPacket(ifname_, cmd_id);
473 return createWifiStatusFromLegacyError(legacy_status);
474}
475
476ndk::ScopedAStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
477 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startPktFateMonitoring(ifname_);
478 return createWifiStatusFromLegacyError(legacy_status);
479}
480
481std::pair<std::vector<WifiDebugTxPacketFateReport>, ndk::ScopedAStatus>
482WifiStaIface::getDebugTxPacketFatesInternal() {
483 legacy_hal::wifi_error legacy_status;
484 std::vector<legacy_hal::wifi_tx_report> legacy_fates;
485 std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getTxPktFates(ifname_);
486 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
487 return {std::vector<WifiDebugTxPacketFateReport>(),
488 createWifiStatusFromLegacyError(legacy_status)};
489 }
490 std::vector<WifiDebugTxPacketFateReport> aidl_fates;
491 if (!aidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToAidl(legacy_fates,
492 &aidl_fates)) {
493 return {std::vector<WifiDebugTxPacketFateReport>(),
494 createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
495 }
496 return {aidl_fates, ndk::ScopedAStatus::ok()};
497}
498
499std::pair<std::vector<WifiDebugRxPacketFateReport>, ndk::ScopedAStatus>
500WifiStaIface::getDebugRxPacketFatesInternal() {
501 legacy_hal::wifi_error legacy_status;
502 std::vector<legacy_hal::wifi_rx_report> legacy_fates;
503 std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getRxPktFates(ifname_);
504 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
505 return {std::vector<WifiDebugRxPacketFateReport>(),
506 createWifiStatusFromLegacyError(legacy_status)};
507 }
508 std::vector<WifiDebugRxPacketFateReport> aidl_fates;
509 if (!aidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToAidl(legacy_fates,
510 &aidl_fates)) {
511 return {std::vector<WifiDebugRxPacketFateReport>(),
512 createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
513 }
514 return {aidl_fates, ndk::ScopedAStatus::ok()};
515}
516
517ndk::ScopedAStatus WifiStaIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
518 bool status = iface_util_.lock()->setMacAddress(ifname_, mac);
519 if (!status) {
520 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
521 }
522 return ndk::ScopedAStatus::ok();
523}
524
525std::pair<std::array<uint8_t, 6>, ndk::ScopedAStatus> WifiStaIface::getFactoryMacAddressInternal() {
526 std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifname_);
527 if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
528 return {mac, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
529 }
530 return {mac, ndk::ScopedAStatus::ok()};
531}
532
533ndk::ScopedAStatus WifiStaIface::setScanModeInternal(bool enable) {
Ye Jiao50274f72023-01-17 14:53:22 +0800534 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setScanMode(ifname_, enable);
535 return createWifiStatusFromLegacyError(legacy_status);
Gabriel Birenf3262f92022-07-15 23:25:39 +0000536}
537
Kai Shi6d02d402022-11-17 16:34:05 -0800538ndk::ScopedAStatus WifiStaIface::setDtimMultiplierInternal(const int multiplier) {
539 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setDtimConfig(ifname_, multiplier);
540 return createWifiStatusFromLegacyError(legacy_status);
541}
542
Gabriel Birenf3262f92022-07-15 23:25:39 +0000543} // namespace wifi
544} // namespace hardware
545} // namespace android
546} // namespace aidl