blob: 0b75ccbe32b129795480f555f3e34d7a6ff0c741 [file] [log] [blame]
Roshan Pius3e2d6712016-10-06 13:16:23 -07001/*
2 * Copyright (C) 2016 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
Roshan Pius3e2d6712016-10-06 13:16:23 -070017#include <android-base/logging.h>
18
Roshan Pius907d4a22016-10-27 12:48:12 -070019#include "hidl_return_util.h"
Roshan Pius970f0312016-12-05 15:25:51 -080020#include "hidl_struct_util.h"
Roshan Pius907d4a22016-10-27 12:48:12 -070021#include "wifi_sta_iface.h"
Roshan Pius734fea02016-10-11 08:30:28 -070022#include "wifi_status_util.h"
Roshan Pius3e2d6712016-10-06 13:16:23 -070023
24namespace android {
25namespace hardware {
26namespace wifi {
27namespace V1_0 {
28namespace implementation {
Roshan Pius907d4a22016-10-27 12:48:12 -070029using hidl_return_util::validateAndCall;
Roshan Pius3e2d6712016-10-06 13:16:23 -070030
Roshan Pius6cedc972016-10-28 10:11:17 -070031WifiStaIface::WifiStaIface(
32 const std::string& ifname,
33 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
Roshan Pius08d1df42017-04-19 23:11:07 -070034 : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {
35 // Turn on DFS channel usage for STA iface.
36 legacy_hal::wifi_error legacy_status =
37 legacy_hal_.lock()->setDfsFlag(true);
38 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
39 LOG(ERROR) << "Failed to set DFS flag; DFS channels may be unavailable.";
40 }
41}
Roshan Pius3e2d6712016-10-06 13:16:23 -070042
43void WifiStaIface::invalidate() {
44 legacy_hal_.reset();
Roshan Piusd37341f2017-01-31 13:13:28 -080045 event_cb_handler_.invalidate();
Roshan Pius3e2d6712016-10-06 13:16:23 -070046 is_valid_ = false;
47}
48
Roshan Pius907d4a22016-10-27 12:48:12 -070049bool WifiStaIface::isValid() {
50 return is_valid_;
51}
52
Roshan Piusd37341f2017-01-31 13:13:28 -080053std::set<sp<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() {
54 return event_cb_handler_.getCallbacks();
Roshan Pius970f0312016-12-05 15:25:51 -080055}
56
Roshan Pius734fea02016-10-11 08:30:28 -070057Return<void> WifiStaIface::getName(getName_cb hidl_status_cb) {
Roshan Pius907d4a22016-10-27 12:48:12 -070058 return validateAndCall(this,
59 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
60 &WifiStaIface::getNameInternal,
61 hidl_status_cb);
Roshan Pius3e2d6712016-10-06 13:16:23 -070062}
63
Roshan Pius734fea02016-10-11 08:30:28 -070064Return<void> WifiStaIface::getType(getType_cb hidl_status_cb) {
Roshan Pius907d4a22016-10-27 12:48:12 -070065 return validateAndCall(this,
66 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
67 &WifiStaIface::getTypeInternal,
68 hidl_status_cb);
69}
70
Roshan Piusa04ba3f2016-10-27 14:36:26 -070071Return<void> WifiStaIface::registerEventCallback(
72 const sp<IWifiStaIfaceEventCallback>& callback,
73 registerEventCallback_cb hidl_status_cb) {
74 return validateAndCall(this,
75 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
76 &WifiStaIface::registerEventCallbackInternal,
77 hidl_status_cb,
78 callback);
79}
80
81Return<void> WifiStaIface::getCapabilities(getCapabilities_cb hidl_status_cb) {
82 return validateAndCall(this,
83 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
84 &WifiStaIface::getCapabilitiesInternal,
85 hidl_status_cb);
86}
87
88Return<void> WifiStaIface::getApfPacketFilterCapabilities(
89 getApfPacketFilterCapabilities_cb hidl_status_cb) {
90 return validateAndCall(this,
91 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
92 &WifiStaIface::getApfPacketFilterCapabilitiesInternal,
93 hidl_status_cb);
94}
95
96Return<void> WifiStaIface::installApfPacketFilter(
97 uint32_t cmd_id,
98 const hidl_vec<uint8_t>& program,
99 installApfPacketFilter_cb hidl_status_cb) {
100 return validateAndCall(this,
101 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
102 &WifiStaIface::installApfPacketFilterInternal,
103 hidl_status_cb,
104 cmd_id,
105 program);
106}
107
108Return<void> WifiStaIface::getBackgroundScanCapabilities(
109 getBackgroundScanCapabilities_cb hidl_status_cb) {
110 return validateAndCall(this,
111 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
112 &WifiStaIface::getBackgroundScanCapabilitiesInternal,
113 hidl_status_cb);
114}
115
Roshan Pius7f4574d2017-02-22 09:48:03 -0800116Return<void> WifiStaIface::getValidFrequenciesForBand(
117 WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) {
118 return validateAndCall(this,
119 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
120 &WifiStaIface::getValidFrequenciesForBandInternal,
121 hidl_status_cb,
122 band);
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700123}
124
125Return<void> WifiStaIface::startBackgroundScan(
126 uint32_t cmd_id,
127 const StaBackgroundScanParameters& params,
128 startBackgroundScan_cb hidl_status_cb) {
129 return validateAndCall(this,
130 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
131 &WifiStaIface::startBackgroundScanInternal,
132 hidl_status_cb,
133 cmd_id,
134 params);
135}
136
137Return<void> WifiStaIface::stopBackgroundScan(
138 uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) {
139 return validateAndCall(this,
140 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
141 &WifiStaIface::stopBackgroundScanInternal,
142 hidl_status_cb,
143 cmd_id);
144}
145
146Return<void> WifiStaIface::enableLinkLayerStatsCollection(
147 bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) {
148 return validateAndCall(this,
149 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
150 &WifiStaIface::enableLinkLayerStatsCollectionInternal,
151 hidl_status_cb,
152 debug);
153}
154
155Return<void> WifiStaIface::disableLinkLayerStatsCollection(
156 disableLinkLayerStatsCollection_cb hidl_status_cb) {
157 return validateAndCall(this,
158 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
159 &WifiStaIface::disableLinkLayerStatsCollectionInternal,
160 hidl_status_cb);
161}
162
163Return<void> WifiStaIface::getLinkLayerStats(
164 getLinkLayerStats_cb hidl_status_cb) {
165 return validateAndCall(this,
166 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
167 &WifiStaIface::getLinkLayerStatsInternal,
168 hidl_status_cb);
169}
170
Roshan Piusd4767542016-12-06 10:04:05 -0800171Return<void> WifiStaIface::startRssiMonitoring(
172 uint32_t cmd_id,
173 int32_t max_rssi,
174 int32_t min_rssi,
175 startRssiMonitoring_cb hidl_status_cb) {
176 return validateAndCall(this,
177 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
178 &WifiStaIface::startRssiMonitoringInternal,
179 hidl_status_cb,
180 cmd_id,
181 max_rssi,
182 min_rssi);
183}
184
185Return<void> WifiStaIface::stopRssiMonitoring(
186 uint32_t cmd_id, stopRssiMonitoring_cb hidl_status_cb) {
187 return validateAndCall(this,
188 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
189 &WifiStaIface::stopRssiMonitoringInternal,
190 hidl_status_cb,
191 cmd_id);
192}
193
Roshan Pius26801cb2016-12-13 14:25:45 -0800194Return<void> WifiStaIface::getRoamingCapabilities(
195 getRoamingCapabilities_cb hidl_status_cb) {
196 return validateAndCall(this,
197 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
198 &WifiStaIface::getRoamingCapabilitiesInternal,
199 hidl_status_cb);
200}
201
202Return<void> WifiStaIface::configureRoaming(
203 const StaRoamingConfig& config, configureRoaming_cb hidl_status_cb) {
204 return validateAndCall(this,
205 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
206 &WifiStaIface::configureRoamingInternal,
207 hidl_status_cb,
208 config);
209}
210
211Return<void> WifiStaIface::setRoamingState(StaRoamingState state,
212 setRoamingState_cb hidl_status_cb) {
213 return validateAndCall(this,
214 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
215 &WifiStaIface::setRoamingStateInternal,
216 hidl_status_cb,
217 state);
218}
219
Roshan Piusaf727c02017-01-11 15:37:25 -0800220Return<void> WifiStaIface::enableNdOffload(bool enable,
221 enableNdOffload_cb hidl_status_cb) {
222 return validateAndCall(this,
223 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
224 &WifiStaIface::enableNdOffloadInternal,
225 hidl_status_cb,
226 enable);
227}
228
Roshan Pius9a9869a2017-01-11 16:42:16 -0800229Return<void> WifiStaIface::startSendingKeepAlivePackets(
230 uint32_t cmd_id,
231 const hidl_vec<uint8_t>& ip_packet_data,
232 uint16_t ether_type,
233 const hidl_array<uint8_t, 6>& src_address,
234 const hidl_array<uint8_t, 6>& dst_address,
235 uint32_t period_in_ms,
236 startSendingKeepAlivePackets_cb hidl_status_cb) {
237 return validateAndCall(this,
238 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
239 &WifiStaIface::startSendingKeepAlivePacketsInternal,
240 hidl_status_cb,
241 cmd_id,
242 ip_packet_data,
243 ether_type,
244 src_address,
245 dst_address,
246 period_in_ms);
247}
248
249Return<void> WifiStaIface::stopSendingKeepAlivePackets(
250 uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) {
251 return validateAndCall(this,
252 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
253 &WifiStaIface::stopSendingKeepAlivePacketsInternal,
254 hidl_status_cb,
255 cmd_id);
256}
257
Roshan Pius795bb812017-02-01 13:09:08 -0800258Return<void> WifiStaIface::setScanningMacOui(
259 const hidl_array<uint8_t, 3>& oui, setScanningMacOui_cb hidl_status_cb) {
260 return validateAndCall(this,
261 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
262 &WifiStaIface::setScanningMacOuiInternal,
263 hidl_status_cb,
264 oui);
265}
266
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700267Return<void> WifiStaIface::startDebugPacketFateMonitoring(
268 startDebugPacketFateMonitoring_cb hidl_status_cb) {
269 return validateAndCall(this,
270 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
271 &WifiStaIface::startDebugPacketFateMonitoringInternal,
272 hidl_status_cb);
273}
274
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700275Return<void> WifiStaIface::getDebugTxPacketFates(
276 getDebugTxPacketFates_cb hidl_status_cb) {
277 return validateAndCall(this,
278 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
279 &WifiStaIface::getDebugTxPacketFatesInternal,
280 hidl_status_cb);
281}
282
283Return<void> WifiStaIface::getDebugRxPacketFates(
284 getDebugRxPacketFates_cb hidl_status_cb) {
285 return validateAndCall(this,
286 WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
287 &WifiStaIface::getDebugRxPacketFatesInternal,
288 hidl_status_cb);
289}
290
Roshan Pius907d4a22016-10-27 12:48:12 -0700291std::pair<WifiStatus, std::string> WifiStaIface::getNameInternal() {
292 return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
293}
294
295std::pair<WifiStatus, IfaceType> WifiStaIface::getTypeInternal() {
296 return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::STA};
Roshan Pius3e2d6712016-10-06 13:16:23 -0700297}
298
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700299WifiStatus WifiStaIface::registerEventCallbackInternal(
300 const sp<IWifiStaIfaceEventCallback>& callback) {
Roshan Piusd37341f2017-01-31 13:13:28 -0800301 if (!event_cb_handler_.addCallback(callback)) {
302 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
303 }
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700304 return createWifiStatus(WifiStatusCode::SUCCESS);
305}
306
307std::pair<WifiStatus, uint32_t> WifiStaIface::getCapabilitiesInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800308 legacy_hal::wifi_error legacy_status;
309 uint32_t legacy_feature_set;
310 std::tie(legacy_status, legacy_feature_set) =
311 legacy_hal_.lock()->getSupportedFeatureSet();
312 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
313 return {createWifiStatusFromLegacyError(legacy_status), 0};
314 }
315 uint32_t legacy_logger_feature_set;
316 std::tie(legacy_status, legacy_logger_feature_set) =
317 legacy_hal_.lock()->getLoggerSupportedFeatureSet();
318 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
319 return {createWifiStatusFromLegacyError(legacy_status), 0};
320 }
321 uint32_t hidl_caps;
322 if (!hidl_struct_util::convertLegacyFeaturesToHidlStaCapabilities(
323 legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
324 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
325 }
326 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700327}
328
329std::pair<WifiStatus, StaApfPacketFilterCapabilities>
330WifiStaIface::getApfPacketFilterCapabilitiesInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800331 legacy_hal::wifi_error legacy_status;
332 legacy_hal::PacketFilterCapabilities legacy_caps;
333 std::tie(legacy_status, legacy_caps) =
334 legacy_hal_.lock()->getPacketFilterCapabilities();
335 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
336 return {createWifiStatusFromLegacyError(legacy_status), {}};
337 }
338 StaApfPacketFilterCapabilities hidl_caps;
339 if (!hidl_struct_util::convertLegacyApfCapabilitiesToHidl(legacy_caps,
340 &hidl_caps)) {
341 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
342 }
343 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700344}
345
346WifiStatus WifiStaIface::installApfPacketFilterInternal(
Roshan Pius970f0312016-12-05 15:25:51 -0800347 uint32_t /* cmd_id */, const std::vector<uint8_t>& program) {
348 legacy_hal::wifi_error legacy_status =
349 legacy_hal_.lock()->setPacketFilter(program);
350 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700351}
352
353std::pair<WifiStatus, StaBackgroundScanCapabilities>
354WifiStaIface::getBackgroundScanCapabilitiesInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800355 legacy_hal::wifi_error legacy_status;
356 legacy_hal::wifi_gscan_capabilities legacy_caps;
357 std::tie(legacy_status, legacy_caps) =
358 legacy_hal_.lock()->getGscanCapabilities();
359 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
360 return {createWifiStatusFromLegacyError(legacy_status), {}};
361 }
362 StaBackgroundScanCapabilities hidl_caps;
363 if (!hidl_struct_util::convertLegacyGscanCapabilitiesToHidl(legacy_caps,
364 &hidl_caps)) {
365 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
366 }
367 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700368}
369
370std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
Roshan Pius7f4574d2017-02-22 09:48:03 -0800371WifiStaIface::getValidFrequenciesForBandInternal(WifiBand band) {
Roshan Pius970f0312016-12-05 15:25:51 -0800372 static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), "Size mismatch");
373 legacy_hal::wifi_error legacy_status;
374 std::vector<uint32_t> valid_frequencies;
375 std::tie(legacy_status, valid_frequencies) =
Roshan Pius7f4574d2017-02-22 09:48:03 -0800376 legacy_hal_.lock()->getValidFrequenciesForBand(
377 hidl_struct_util::convertHidlWifiBandToLegacy(band));
Roshan Pius970f0312016-12-05 15:25:51 -0800378 return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700379}
380
381WifiStatus WifiStaIface::startBackgroundScanInternal(
Roshan Pius970f0312016-12-05 15:25:51 -0800382 uint32_t cmd_id, const StaBackgroundScanParameters& params) {
383 legacy_hal::wifi_scan_cmd_params legacy_params;
384 if (!hidl_struct_util::convertHidlGscanParamsToLegacy(params,
385 &legacy_params)) {
386 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
387 }
388 android::wp<WifiStaIface> weak_ptr_this(this);
389 const auto& on_failure_callback =
390 [weak_ptr_this](legacy_hal::wifi_request_id id) {
391 const auto shared_ptr_this = weak_ptr_this.promote();
392 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
393 LOG(ERROR) << "Callback invoked on an invalid object";
394 return;
395 }
396 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
Roshan Piusbc662202017-01-30 17:07:42 -0800397 if (!callback->onBackgroundScanFailure(id).isOk()) {
398 LOG(ERROR) << "Failed to invoke onBackgroundScanFailure callback";
399 }
Roshan Pius970f0312016-12-05 15:25:51 -0800400 }
401 };
402 const auto& on_results_callback = [weak_ptr_this](
403 legacy_hal::wifi_request_id id,
404 const std::vector<legacy_hal::wifi_cached_scan_results>& results) {
405 const auto shared_ptr_this = weak_ptr_this.promote();
406 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
407 LOG(ERROR) << "Callback invoked on an invalid object";
408 return;
409 }
410 std::vector<StaScanData> hidl_scan_datas;
411 if (!hidl_struct_util::convertLegacyVectorOfCachedGscanResultsToHidl(
412 results, &hidl_scan_datas)) {
413 LOG(ERROR) << "Failed to convert scan results to HIDL structs";
414 return;
415 }
416 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
Roshan Piusbc662202017-01-30 17:07:42 -0800417 if (!callback->onBackgroundScanResults(id, hidl_scan_datas).isOk()) {
418 LOG(ERROR) << "Failed to invoke onBackgroundScanResults callback";
419 }
Roshan Pius970f0312016-12-05 15:25:51 -0800420 }
421 };
422 const auto& on_full_result_callback = [weak_ptr_this](
423 legacy_hal::wifi_request_id id,
424 const legacy_hal::wifi_scan_result* result,
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800425 uint32_t buckets_scanned) {
Roshan Pius970f0312016-12-05 15:25:51 -0800426 const auto shared_ptr_this = weak_ptr_this.promote();
427 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
428 LOG(ERROR) << "Callback invoked on an invalid object";
429 return;
430 }
431 StaScanResult hidl_scan_result;
432 if (!hidl_struct_util::convertLegacyGscanResultToHidl(
433 *result, true, &hidl_scan_result)) {
434 LOG(ERROR) << "Failed to convert full scan results to HIDL structs";
435 return;
436 }
437 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
Roshan Pius8c0c8e92017-02-24 08:07:42 -0800438 if (!callback->onBackgroundFullScanResult(
439 id, buckets_scanned, hidl_scan_result).isOk()) {
Roshan Piusbc662202017-01-30 17:07:42 -0800440 LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback";
441 }
Roshan Pius970f0312016-12-05 15:25:51 -0800442 }
443 };
444 legacy_hal::wifi_error legacy_status =
445 legacy_hal_.lock()->startGscan(cmd_id,
446 legacy_params,
447 on_failure_callback,
448 on_results_callback,
449 on_full_result_callback);
450 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700451}
452
Roshan Pius970f0312016-12-05 15:25:51 -0800453WifiStatus WifiStaIface::stopBackgroundScanInternal(uint32_t cmd_id) {
454 legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopGscan(cmd_id);
455 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700456}
457
Roshan Pius970f0312016-12-05 15:25:51 -0800458WifiStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) {
459 legacy_hal::wifi_error legacy_status =
460 legacy_hal_.lock()->enableLinkLayerStats(debug);
461 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700462}
463
464WifiStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800465 legacy_hal::wifi_error legacy_status =
466 legacy_hal_.lock()->disableLinkLayerStats();
467 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700468}
469
470std::pair<WifiStatus, StaLinkLayerStats>
471WifiStaIface::getLinkLayerStatsInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800472 legacy_hal::wifi_error legacy_status;
473 legacy_hal::LinkLayerStats legacy_stats;
474 std::tie(legacy_status, legacy_stats) =
475 legacy_hal_.lock()->getLinkLayerStats();
476 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
477 return {createWifiStatusFromLegacyError(legacy_status), {}};
478 }
479 StaLinkLayerStats hidl_stats;
480 if (!hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats,
481 &hidl_stats)) {
482 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
483 }
484 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700485}
486
Roshan Piusd4767542016-12-06 10:04:05 -0800487WifiStatus WifiStaIface::startRssiMonitoringInternal(uint32_t cmd_id,
488 int32_t max_rssi,
489 int32_t min_rssi) {
490 android::wp<WifiStaIface> weak_ptr_this(this);
491 const auto& on_threshold_breached_callback = [weak_ptr_this](
492 legacy_hal::wifi_request_id id,
493 std::array<uint8_t, 6> bssid,
494 int8_t rssi) {
495 const auto shared_ptr_this = weak_ptr_this.promote();
496 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
497 LOG(ERROR) << "Callback invoked on an invalid object";
498 return;
499 }
500 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
Roshan Piusbc662202017-01-30 17:07:42 -0800501 if (!callback->onRssiThresholdBreached(id, bssid, rssi).isOk()) {
502 LOG(ERROR) << "Failed to invoke onRssiThresholdBreached callback";
503 }
Roshan Piusd4767542016-12-06 10:04:05 -0800504 }
505 };
506 legacy_hal::wifi_error legacy_status =
507 legacy_hal_.lock()->startRssiMonitoring(
508 cmd_id, max_rssi, min_rssi, on_threshold_breached_callback);
509 return createWifiStatusFromLegacyError(legacy_status);
510}
511
512WifiStatus WifiStaIface::stopRssiMonitoringInternal(uint32_t cmd_id) {
513 legacy_hal::wifi_error legacy_status =
514 legacy_hal_.lock()->stopRssiMonitoring(cmd_id);
515 return createWifiStatusFromLegacyError(legacy_status);
516}
517
Roshan Pius26801cb2016-12-13 14:25:45 -0800518std::pair<WifiStatus, StaRoamingCapabilities>
519WifiStaIface::getRoamingCapabilitiesInternal() {
520 legacy_hal::wifi_error legacy_status;
521 legacy_hal::wifi_roaming_capabilities legacy_caps;
522 std::tie(legacy_status, legacy_caps) =
523 legacy_hal_.lock()->getRoamingCapabilities();
524 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
525 return {createWifiStatusFromLegacyError(legacy_status), {}};
526 }
527 StaRoamingCapabilities hidl_caps;
528 if (!hidl_struct_util::convertLegacyRoamingCapabilitiesToHidl(legacy_caps,
529 &hidl_caps)) {
530 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
531 }
532 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
533}
534
535WifiStatus WifiStaIface::configureRoamingInternal(
536 const StaRoamingConfig& config) {
537 legacy_hal::wifi_roaming_config legacy_config;
538 if (!hidl_struct_util::convertHidlRoamingConfigToLegacy(config,
539 &legacy_config)) {
540 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
541 }
542 legacy_hal::wifi_error legacy_status =
543 legacy_hal_.lock()->configureRoaming(legacy_config);
544 return createWifiStatusFromLegacyError(legacy_status);
545}
546
547WifiStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) {
548 legacy_hal::wifi_error legacy_status =
549 legacy_hal_.lock()->enableFirmwareRoaming(
550 hidl_struct_util::convertHidlRoamingStateToLegacy(state));
551 return createWifiStatusFromLegacyError(legacy_status);
552}
553
Roshan Piusaf727c02017-01-11 15:37:25 -0800554WifiStatus WifiStaIface::enableNdOffloadInternal(bool enable) {
555 legacy_hal::wifi_error legacy_status =
556 legacy_hal_.lock()->configureNdOffload(enable);
557 return createWifiStatusFromLegacyError(legacy_status);
558}
559
Roshan Pius9a9869a2017-01-11 16:42:16 -0800560WifiStatus WifiStaIface::startSendingKeepAlivePacketsInternal(
561 uint32_t cmd_id,
562 const std::vector<uint8_t>& ip_packet_data,
563 uint16_t /* ether_type */,
564 const std::array<uint8_t, 6>& src_address,
565 const std::array<uint8_t, 6>& dst_address,
566 uint32_t period_in_ms) {
567 legacy_hal::wifi_error legacy_status =
568 legacy_hal_.lock()->startSendingOffloadedPacket(
569 cmd_id, ip_packet_data, src_address, dst_address, period_in_ms);
570 return createWifiStatusFromLegacyError(legacy_status);
571}
572
573WifiStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(uint32_t cmd_id) {
574 legacy_hal::wifi_error legacy_status =
575 legacy_hal_.lock()->stopSendingOffloadedPacket(cmd_id);
576 return createWifiStatusFromLegacyError(legacy_status);
577}
578
Roshan Piusd37341f2017-01-31 13:13:28 -0800579WifiStatus WifiStaIface::setScanningMacOuiInternal(
580 const std::array<uint8_t, 3>& oui) {
Roshan Pius795bb812017-02-01 13:09:08 -0800581 legacy_hal::wifi_error legacy_status =
582 legacy_hal_.lock()->setScanningMacOui(oui);
583 return createWifiStatusFromLegacyError(legacy_status);
584}
585
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700586WifiStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800587 legacy_hal::wifi_error legacy_status =
588 legacy_hal_.lock()->startPktFateMonitoring();
589 return createWifiStatusFromLegacyError(legacy_status);
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700590}
591
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700592std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
593WifiStaIface::getDebugTxPacketFatesInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800594 legacy_hal::wifi_error legacy_status;
595 std::vector<legacy_hal::wifi_tx_report> legacy_fates;
596 std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getTxPktFates();
597 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
598 return {createWifiStatusFromLegacyError(legacy_status), {}};
599 }
600 std::vector<WifiDebugTxPacketFateReport> hidl_fates;
601 if (!hidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToHidl(
602 legacy_fates, &hidl_fates)) {
603 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
604 }
605 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700606}
607
608std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>>
609WifiStaIface::getDebugRxPacketFatesInternal() {
Roshan Pius970f0312016-12-05 15:25:51 -0800610 legacy_hal::wifi_error legacy_status;
611 std::vector<legacy_hal::wifi_rx_report> legacy_fates;
612 std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getRxPktFates();
613 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
614 return {createWifiStatusFromLegacyError(legacy_status), {}};
615 }
616 std::vector<WifiDebugRxPacketFateReport> hidl_fates;
617 if (!hidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToHidl(
618 legacy_fates, &hidl_fates)) {
619 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
620 }
621 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
Roshan Piusa04ba3f2016-10-27 14:36:26 -0700622}
623
Roshan Pius3e2d6712016-10-06 13:16:23 -0700624} // namespace implementation
625} // namespace V1_0
626} // namespace wifi
627} // namespace hardware
628} // namespace android