1 /*
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
17 #include <android-base/logging.h>
18
19 #include "hidl_return_util.h"
20 #include "hidl_struct_util.h"
21 #include "wifi_nan_iface.h"
22 #include "wifi_status_util.h"
23
24 namespace android {
25 namespace hardware {
26 namespace wifi {
27 namespace V1_5 {
28 namespace implementation {
29 using hidl_return_util::validateAndCall;
30
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)31 WifiNanIface::WifiNanIface(
32 const std::string& ifname, bool is_dedicated_iface,
33 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
34 const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
35 : ifname_(ifname),
36 is_dedicated_iface_(is_dedicated_iface),
37 legacy_hal_(legacy_hal),
38 iface_util_(iface_util),
39 is_valid_(true) {
40 if (is_dedicated_iface_) {
41 // If using a dedicated iface, set the iface up first.
42 if (!iface_util_.lock()->setUpState(ifname_, true)) {
43 // Fatal failure, invalidate the iface object.
44 invalidate();
45 return;
46 }
47 }
48 // Register all the callbacks here. these should be valid for the lifetime
49 // of the object. Whenever the mode changes legacy HAL will remove
50 // all of these callbacks.
51 legacy_hal::NanCallbackHandlers callback_handlers;
52 android::wp<WifiNanIface> weak_ptr_this(this);
53
54 // Callback for response.
55 callback_handlers
56 .on_notify_response = [weak_ptr_this](
57 legacy_hal::transaction_id id,
58 const legacy_hal::NanResponseMsg& msg) {
59 const auto shared_ptr_this = weak_ptr_this.promote();
60 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
61 LOG(ERROR) << "Callback invoked on an invalid object";
62 return;
63 }
64 WifiNanStatus wifiNanStatus;
65 if (!hidl_struct_util::convertLegacyNanResponseHeaderToHidl(
66 msg, &wifiNanStatus)) {
67 LOG(ERROR) << "Failed to convert nan response header";
68 return;
69 }
70
71 switch (msg.response_type) {
72 case legacy_hal::NAN_RESPONSE_ENABLED: {
73 for (const auto& callback :
74 shared_ptr_this->getEventCallbacks()) {
75 if (!callback->notifyEnableResponse(id, wifiNanStatus)
76 .isOk()) {
77 LOG(ERROR) << "Failed to invoke the callback";
78 }
79 }
80 break;
81 }
82 case legacy_hal::NAN_RESPONSE_DISABLED: {
83 for (const auto& callback :
84 shared_ptr_this->getEventCallbacks()) {
85 if (!callback->notifyDisableResponse(id, wifiNanStatus)
86 .isOk()) {
87 LOG(ERROR) << "Failed to invoke the callback";
88 }
89 }
90 break;
91 }
92 case legacy_hal::NAN_RESPONSE_PUBLISH: {
93 for (const auto& callback :
94 shared_ptr_this->getEventCallbacks()) {
95 if (!callback
96 ->notifyStartPublishResponse(
97 id, wifiNanStatus,
98 msg.body.publish_response.publish_id)
99 .isOk()) {
100 LOG(ERROR) << "Failed to invoke the callback";
101 }
102 }
103 break;
104 }
105 case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL: {
106 for (const auto& callback :
107 shared_ptr_this->getEventCallbacks()) {
108 if (!callback->notifyStopPublishResponse(id, wifiNanStatus)
109 .isOk()) {
110 LOG(ERROR) << "Failed to invoke the callback";
111 }
112 }
113 break;
114 }
115 case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP: {
116 for (const auto& callback :
117 shared_ptr_this->getEventCallbacks()) {
118 if (!callback
119 ->notifyTransmitFollowupResponse(id, wifiNanStatus)
120 .isOk()) {
121 LOG(ERROR) << "Failed to invoke the callback";
122 }
123 }
124 break;
125 }
126 case legacy_hal::NAN_RESPONSE_SUBSCRIBE: {
127 for (const auto& callback :
128 shared_ptr_this->getEventCallbacks()) {
129 if (!callback
130 ->notifyStartSubscribeResponse(
131 id, wifiNanStatus,
132 msg.body.subscribe_response.subscribe_id)
133 .isOk()) {
134 LOG(ERROR) << "Failed to invoke the callback";
135 }
136 }
137 break;
138 }
139 case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL: {
140 for (const auto& callback :
141 shared_ptr_this->getEventCallbacks()) {
142 if (!callback
143 ->notifyStopSubscribeResponse(id, wifiNanStatus)
144 .isOk()) {
145 LOG(ERROR) << "Failed to invoke the callback";
146 }
147 }
148 break;
149 }
150 case legacy_hal::NAN_RESPONSE_CONFIG: {
151 for (const auto& callback :
152 shared_ptr_this->getEventCallbacks()) {
153 if (!callback->notifyConfigResponse(id, wifiNanStatus)
154 .isOk()) {
155 LOG(ERROR) << "Failed to invoke the callback";
156 }
157 }
158 break;
159 }
160 case legacy_hal::NAN_GET_CAPABILITIES: {
161 NanCapabilities hidl_struct;
162 if (!hidl_struct_util::
163 convertLegacyNanCapabilitiesResponseToHidl(
164 msg.body.nan_capabilities, &hidl_struct)) {
165 LOG(ERROR) << "Failed to convert nan capabilities response";
166 return;
167 }
168 for (const auto& callback :
169 shared_ptr_this->getEventCallbacks_1_5()) {
170 if (!callback
171 ->notifyCapabilitiesResponse_1_5(id, wifiNanStatus,
172 hidl_struct)
173 .isOk()) {
174 LOG(ERROR) << "Failed to invoke the callback";
175 }
176 }
177 break;
178 }
179 case legacy_hal::NAN_DP_INTERFACE_CREATE: {
180 for (const auto& callback :
181 shared_ptr_this->getEventCallbacks()) {
182 if (!callback
183 ->notifyCreateDataInterfaceResponse(id,
184 wifiNanStatus)
185 .isOk()) {
186 LOG(ERROR) << "Failed to invoke the callback";
187 }
188 }
189 break;
190 }
191 case legacy_hal::NAN_DP_INTERFACE_DELETE: {
192 for (const auto& callback :
193 shared_ptr_this->getEventCallbacks()) {
194 if (!callback
195 ->notifyDeleteDataInterfaceResponse(id,
196 wifiNanStatus)
197 .isOk()) {
198 LOG(ERROR) << "Failed to invoke the callback";
199 }
200 }
201 break;
202 }
203 case legacy_hal::NAN_DP_INITIATOR_RESPONSE: {
204 for (const auto& callback :
205 shared_ptr_this->getEventCallbacks()) {
206 if (!callback
207 ->notifyInitiateDataPathResponse(
208 id, wifiNanStatus,
209 msg.body.data_request_response.ndp_instance_id)
210 .isOk()) {
211 LOG(ERROR) << "Failed to invoke the callback";
212 }
213 }
214 break;
215 }
216 case legacy_hal::NAN_DP_RESPONDER_RESPONSE: {
217 for (const auto& callback :
218 shared_ptr_this->getEventCallbacks()) {
219 if (!callback
220 ->notifyRespondToDataPathIndicationResponse(
221 id, wifiNanStatus)
222 .isOk()) {
223 LOG(ERROR) << "Failed to invoke the callback";
224 }
225 }
226 break;
227 }
228 case legacy_hal::NAN_DP_END: {
229 for (const auto& callback :
230 shared_ptr_this->getEventCallbacks()) {
231 if (!callback
232 ->notifyTerminateDataPathResponse(id,
233 wifiNanStatus)
234 .isOk()) {
235 LOG(ERROR) << "Failed to invoke the callback";
236 }
237 }
238 break;
239 }
240 case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD:
241 /* fall through */
242 case legacy_hal::NAN_RESPONSE_TCA:
243 /* fall through */
244 case legacy_hal::NAN_RESPONSE_STATS:
245 /* fall through */
246 case legacy_hal::NAN_RESPONSE_ERROR:
247 /* fall through */
248 default:
249 LOG(ERROR) << "Unknown or unhandled response type: "
250 << msg.response_type;
251 return;
252 }
253 };
254
255 callback_handlers.on_event_disc_eng_event =
256 [weak_ptr_this](const legacy_hal::NanDiscEngEventInd& msg) {
257 const auto shared_ptr_this = weak_ptr_this.promote();
258 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
259 LOG(ERROR) << "Callback invoked on an invalid object";
260 return;
261 }
262 NanClusterEventInd hidl_struct;
263 // event types defined identically - hence can be cast
264 hidl_struct.eventType = (NanClusterEventType)msg.event_type;
265 hidl_struct.addr = msg.data.mac_addr.addr;
266
267 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
268 if (!callback->eventClusterEvent(hidl_struct).isOk()) {
269 LOG(ERROR) << "Failed to invoke the callback";
270 }
271 }
272 };
273
274 callback_handlers.on_event_disabled =
275 [weak_ptr_this](const legacy_hal::NanDisabledInd& msg) {
276 const auto shared_ptr_this = weak_ptr_this.promote();
277 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
278 LOG(ERROR) << "Callback invoked on an invalid object";
279 return;
280 }
281 WifiNanStatus status;
282 hidl_struct_util::convertToWifiNanStatus(
283 msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status);
284
285 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
286 if (!callback->eventDisabled(status).isOk()) {
287 LOG(ERROR) << "Failed to invoke the callback";
288 }
289 }
290 };
291
292 callback_handlers.on_event_publish_terminated =
293 [weak_ptr_this](const legacy_hal::NanPublishTerminatedInd& msg) {
294 const auto shared_ptr_this = weak_ptr_this.promote();
295 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
296 LOG(ERROR) << "Callback invoked on an invalid object";
297 return;
298 }
299 WifiNanStatus status;
300 hidl_struct_util::convertToWifiNanStatus(
301 msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status);
302
303 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
304 if (!callback->eventPublishTerminated(msg.publish_id, status)
305 .isOk()) {
306 LOG(ERROR) << "Failed to invoke the callback";
307 }
308 }
309 };
310
311 callback_handlers.on_event_subscribe_terminated =
312 [weak_ptr_this](const legacy_hal::NanSubscribeTerminatedInd& msg) {
313 const auto shared_ptr_this = weak_ptr_this.promote();
314 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
315 LOG(ERROR) << "Callback invoked on an invalid object";
316 return;
317 }
318 WifiNanStatus status;
319 hidl_struct_util::convertToWifiNanStatus(
320 msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status);
321
322 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
323 if (!callback
324 ->eventSubscribeTerminated(msg.subscribe_id, status)
325 .isOk()) {
326 LOG(ERROR) << "Failed to invoke the callback";
327 }
328 }
329 };
330
331 callback_handlers.on_event_match =
332 [weak_ptr_this](const legacy_hal::NanMatchInd& msg) {
333 const auto shared_ptr_this = weak_ptr_this.promote();
334 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
335 LOG(ERROR) << "Callback invoked on an invalid object";
336 return;
337 }
338 NanMatchInd hidl_struct;
339 if (!hidl_struct_util::convertLegacyNanMatchIndToHidl(
340 msg, &hidl_struct)) {
341 LOG(ERROR) << "Failed to convert nan capabilities response";
342 return;
343 }
344
345 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
346 if (!callback->eventMatch(hidl_struct).isOk()) {
347 LOG(ERROR) << "Failed to invoke the callback";
348 }
349 }
350 };
351
352 callback_handlers.on_event_match_expired =
353 [weak_ptr_this](const legacy_hal::NanMatchExpiredInd& msg) {
354 const auto shared_ptr_this = weak_ptr_this.promote();
355 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
356 LOG(ERROR) << "Callback invoked on an invalid object";
357 return;
358 }
359 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
360 if (!callback
361 ->eventMatchExpired(msg.publish_subscribe_id,
362 msg.requestor_instance_id)
363 .isOk()) {
364 LOG(ERROR) << "Failed to invoke the callback";
365 }
366 }
367 };
368
369 callback_handlers.on_event_followup =
370 [weak_ptr_this](const legacy_hal::NanFollowupInd& msg) {
371 const auto shared_ptr_this = weak_ptr_this.promote();
372 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
373 LOG(ERROR) << "Callback invoked on an invalid object";
374 return;
375 }
376 NanFollowupReceivedInd hidl_struct;
377 if (!hidl_struct_util::convertLegacyNanFollowupIndToHidl(
378 msg, &hidl_struct)) {
379 LOG(ERROR) << "Failed to convert nan capabilities response";
380 return;
381 }
382
383 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
384 if (!callback->eventFollowupReceived(hidl_struct).isOk()) {
385 LOG(ERROR) << "Failed to invoke the callback";
386 }
387 }
388 };
389
390 callback_handlers.on_event_transmit_follow_up =
391 [weak_ptr_this](const legacy_hal::NanTransmitFollowupInd& msg) {
392 const auto shared_ptr_this = weak_ptr_this.promote();
393 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
394 LOG(ERROR) << "Callback invoked on an invalid object";
395 return;
396 }
397 WifiNanStatus status;
398 hidl_struct_util::convertToWifiNanStatus(
399 msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status);
400
401 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
402 if (!callback->eventTransmitFollowup(msg.id, status).isOk()) {
403 LOG(ERROR) << "Failed to invoke the callback";
404 }
405 }
406 };
407
408 callback_handlers.on_event_data_path_request =
409 [weak_ptr_this](const legacy_hal::NanDataPathRequestInd& msg) {
410 const auto shared_ptr_this = weak_ptr_this.promote();
411 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
412 LOG(ERROR) << "Callback invoked on an invalid object";
413 return;
414 }
415 NanDataPathRequestInd hidl_struct;
416 if (!hidl_struct_util::convertLegacyNanDataPathRequestIndToHidl(
417 msg, &hidl_struct)) {
418 LOG(ERROR) << "Failed to convert nan capabilities response";
419 return;
420 }
421
422 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
423 if (!callback->eventDataPathRequest(hidl_struct).isOk()) {
424 LOG(ERROR) << "Failed to invoke the callback";
425 }
426 }
427 };
428
429 callback_handlers.on_event_data_path_confirm =
430 [weak_ptr_this](const legacy_hal::NanDataPathConfirmInd& msg) {
431 const auto shared_ptr_this = weak_ptr_this.promote();
432 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
433 LOG(ERROR) << "Callback invoked on an invalid object";
434 return;
435 }
436 V1_2::NanDataPathConfirmInd hidl_struct;
437 if (!hidl_struct_util::convertLegacyNanDataPathConfirmIndToHidl(
438 msg, &hidl_struct)) {
439 LOG(ERROR) << "Failed to convert nan capabilities response";
440 return;
441 }
442
443 for (const auto& callback :
444 shared_ptr_this->getEventCallbacks_1_2()) {
445 if (!callback->eventDataPathConfirm_1_2(hidl_struct).isOk()) {
446 LOG(ERROR) << "Failed to invoke the callback";
447 }
448 }
449 };
450
451 callback_handlers.on_event_data_path_end =
452 [weak_ptr_this](const legacy_hal::NanDataPathEndInd& msg) {
453 const auto shared_ptr_this = weak_ptr_this.promote();
454 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
455 LOG(ERROR) << "Callback invoked on an invalid object";
456 return;
457 }
458 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
459 for (int i = 0; i < msg.num_ndp_instances; ++i) {
460 if (!callback
461 ->eventDataPathTerminated(msg.ndp_instance_id[i])
462 .isOk()) {
463 LOG(ERROR) << "Failed to invoke the callback";
464 }
465 }
466 }
467 };
468
469 callback_handlers.on_event_beacon_sdf_payload =
470 [weak_ptr_this](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) {
471 LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called";
472 };
473
474 callback_handlers.on_event_range_request =
475 [weak_ptr_this](const legacy_hal::NanRangeRequestInd& /* msg */) {
476 LOG(ERROR) << "on_event_range_request - should not be called";
477 };
478
479 callback_handlers.on_event_range_report =
480 [weak_ptr_this](const legacy_hal::NanRangeReportInd& /* msg */) {
481 LOG(ERROR) << "on_event_range_report - should not be called";
482 };
483
484 callback_handlers
485 .on_event_schedule_update = [weak_ptr_this](
486 const legacy_hal::
487 NanDataPathScheduleUpdateInd& msg) {
488 const auto shared_ptr_this = weak_ptr_this.promote();
489 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
490 LOG(ERROR) << "Callback invoked on an invalid object";
491 return;
492 }
493 V1_2::NanDataPathScheduleUpdateInd hidl_struct;
494 if (!hidl_struct_util::convertLegacyNanDataPathScheduleUpdateIndToHidl(
495 msg, &hidl_struct)) {
496 LOG(ERROR) << "Failed to convert nan capabilities response";
497 return;
498 }
499
500 for (const auto& callback : shared_ptr_this->getEventCallbacks_1_2()) {
501 if (!callback->eventDataPathScheduleUpdate(hidl_struct).isOk()) {
502 LOG(ERROR) << "Failed to invoke the callback";
503 }
504 }
505 };
506
507 legacy_hal::wifi_error legacy_status =
508 legacy_hal_.lock()->nanRegisterCallbackHandlers(ifname_,
509 callback_handlers);
510 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
511 LOG(ERROR) << "Failed to register nan callbacks. Invalidating object";
512 invalidate();
513 }
514
515 // Register for iface state toggle events.
516 iface_util::IfaceEventHandlers event_handlers = {};
517 event_handlers.on_state_toggle_off_on =
518 [weak_ptr_this](const std::string& /* iface_name */) {
519 const auto shared_ptr_this = weak_ptr_this.promote();
520 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
521 LOG(ERROR) << "Callback invoked on an invalid object";
522 return;
523 }
524 // Tell framework that NAN has been disabled.
525 WifiNanStatus status = {
526 NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
527 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
528 if (!callback->eventDisabled(status).isOk()) {
529 LOG(ERROR) << "Failed to invoke the callback";
530 }
531 }
532 };
533 iface_util_.lock()->registerIfaceEventHandlers(ifname_, event_handlers);
534 }
535
invalidate()536 void WifiNanIface::invalidate() {
537 if (!isValid()) {
538 return;
539 }
540 // send commands to HAL to actually disable and destroy interfaces
541 legacy_hal_.lock()->nanDisableRequest(ifname_, 0xFFFF);
542 legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFE, "aware_data0");
543 legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFD, "aware_data1");
544 iface_util_.lock()->unregisterIfaceEventHandlers(ifname_);
545 legacy_hal_.reset();
546 event_cb_handler_.invalidate();
547 event_cb_handler_1_2_.invalidate();
548 event_cb_handler_1_5_.invalidate();
549 is_valid_ = false;
550 if (is_dedicated_iface_) {
551 // If using a dedicated iface, set the iface down.
552 iface_util_.lock()->setUpState(ifname_, false);
553 }
554 }
555
isValid()556 bool WifiNanIface::isValid() { return is_valid_; }
557
getName()558 std::string WifiNanIface::getName() { return ifname_; }
559
560 std::set<sp<V1_0::IWifiNanIfaceEventCallback>>
getEventCallbacks()561 WifiNanIface::getEventCallbacks() {
562 return event_cb_handler_.getCallbacks();
563 }
564
565 std::set<sp<V1_2::IWifiNanIfaceEventCallback>>
getEventCallbacks_1_2()566 WifiNanIface::getEventCallbacks_1_2() {
567 return event_cb_handler_1_2_.getCallbacks();
568 }
569
getEventCallbacks_1_5()570 std::set<sp<IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks_1_5() {
571 return event_cb_handler_1_5_.getCallbacks();
572 }
573
getName(getName_cb hidl_status_cb)574 Return<void> WifiNanIface::getName(getName_cb hidl_status_cb) {
575 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
576 &WifiNanIface::getNameInternal, hidl_status_cb);
577 }
578
getType(getType_cb hidl_status_cb)579 Return<void> WifiNanIface::getType(getType_cb hidl_status_cb) {
580 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
581 &WifiNanIface::getTypeInternal, hidl_status_cb);
582 }
583
registerEventCallback(const sp<V1_0::IWifiNanIfaceEventCallback> & callback,registerEventCallback_cb hidl_status_cb)584 Return<void> WifiNanIface::registerEventCallback(
585 const sp<V1_0::IWifiNanIfaceEventCallback>& callback,
586 registerEventCallback_cb hidl_status_cb) {
587 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
588 &WifiNanIface::registerEventCallbackInternal,
589 hidl_status_cb, callback);
590 }
591
getCapabilitiesRequest(uint16_t cmd_id,getCapabilitiesRequest_cb hidl_status_cb)592 Return<void> WifiNanIface::getCapabilitiesRequest(
593 uint16_t cmd_id, getCapabilitiesRequest_cb hidl_status_cb) {
594 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
595 &WifiNanIface::getCapabilitiesRequestInternal,
596 hidl_status_cb, cmd_id);
597 }
598
enableRequest(uint16_t cmd_id,const V1_0::NanEnableRequest & msg,enableRequest_cb hidl_status_cb)599 Return<void> WifiNanIface::enableRequest(uint16_t cmd_id,
600 const V1_0::NanEnableRequest& msg,
601 enableRequest_cb hidl_status_cb) {
602 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
603 &WifiNanIface::enableRequestInternal, hidl_status_cb,
604 cmd_id, msg);
605 }
606
configRequest(uint16_t cmd_id,const V1_0::NanConfigRequest & msg,configRequest_cb hidl_status_cb)607 Return<void> WifiNanIface::configRequest(uint16_t cmd_id,
608 const V1_0::NanConfigRequest& msg,
609 configRequest_cb hidl_status_cb) {
610 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
611 &WifiNanIface::configRequestInternal, hidl_status_cb,
612 cmd_id, msg);
613 }
614
disableRequest(uint16_t cmd_id,disableRequest_cb hidl_status_cb)615 Return<void> WifiNanIface::disableRequest(uint16_t cmd_id,
616 disableRequest_cb hidl_status_cb) {
617 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
618 &WifiNanIface::disableRequestInternal,
619 hidl_status_cb, cmd_id);
620 }
621
startPublishRequest(uint16_t cmd_id,const NanPublishRequest & msg,startPublishRequest_cb hidl_status_cb)622 Return<void> WifiNanIface::startPublishRequest(
623 uint16_t cmd_id, const NanPublishRequest& msg,
624 startPublishRequest_cb hidl_status_cb) {
625 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
626 &WifiNanIface::startPublishRequestInternal,
627 hidl_status_cb, cmd_id, msg);
628 }
629
stopPublishRequest(uint16_t cmd_id,uint8_t sessionId,stopPublishRequest_cb hidl_status_cb)630 Return<void> WifiNanIface::stopPublishRequest(
631 uint16_t cmd_id, uint8_t sessionId, stopPublishRequest_cb hidl_status_cb) {
632 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
633 &WifiNanIface::stopPublishRequestInternal,
634 hidl_status_cb, cmd_id, sessionId);
635 }
636
startSubscribeRequest(uint16_t cmd_id,const NanSubscribeRequest & msg,startSubscribeRequest_cb hidl_status_cb)637 Return<void> WifiNanIface::startSubscribeRequest(
638 uint16_t cmd_id, const NanSubscribeRequest& msg,
639 startSubscribeRequest_cb hidl_status_cb) {
640 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
641 &WifiNanIface::startSubscribeRequestInternal,
642 hidl_status_cb, cmd_id, msg);
643 }
644
stopSubscribeRequest(uint16_t cmd_id,uint8_t sessionId,stopSubscribeRequest_cb hidl_status_cb)645 Return<void> WifiNanIface::stopSubscribeRequest(
646 uint16_t cmd_id, uint8_t sessionId,
647 stopSubscribeRequest_cb hidl_status_cb) {
648 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
649 &WifiNanIface::stopSubscribeRequestInternal,
650 hidl_status_cb, cmd_id, sessionId);
651 }
652
transmitFollowupRequest(uint16_t cmd_id,const NanTransmitFollowupRequest & msg,transmitFollowupRequest_cb hidl_status_cb)653 Return<void> WifiNanIface::transmitFollowupRequest(
654 uint16_t cmd_id, const NanTransmitFollowupRequest& msg,
655 transmitFollowupRequest_cb hidl_status_cb) {
656 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
657 &WifiNanIface::transmitFollowupRequestInternal,
658 hidl_status_cb, cmd_id, msg);
659 }
660
createDataInterfaceRequest(uint16_t cmd_id,const hidl_string & iface_name,createDataInterfaceRequest_cb hidl_status_cb)661 Return<void> WifiNanIface::createDataInterfaceRequest(
662 uint16_t cmd_id, const hidl_string& iface_name,
663 createDataInterfaceRequest_cb hidl_status_cb) {
664 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
665 &WifiNanIface::createDataInterfaceRequestInternal,
666 hidl_status_cb, cmd_id, iface_name);
667 }
668
deleteDataInterfaceRequest(uint16_t cmd_id,const hidl_string & iface_name,deleteDataInterfaceRequest_cb hidl_status_cb)669 Return<void> WifiNanIface::deleteDataInterfaceRequest(
670 uint16_t cmd_id, const hidl_string& iface_name,
671 deleteDataInterfaceRequest_cb hidl_status_cb) {
672 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
673 &WifiNanIface::deleteDataInterfaceRequestInternal,
674 hidl_status_cb, cmd_id, iface_name);
675 }
676
initiateDataPathRequest(uint16_t cmd_id,const NanInitiateDataPathRequest & msg,initiateDataPathRequest_cb hidl_status_cb)677 Return<void> WifiNanIface::initiateDataPathRequest(
678 uint16_t cmd_id, const NanInitiateDataPathRequest& msg,
679 initiateDataPathRequest_cb hidl_status_cb) {
680 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
681 &WifiNanIface::initiateDataPathRequestInternal,
682 hidl_status_cb, cmd_id, msg);
683 }
684
respondToDataPathIndicationRequest(uint16_t cmd_id,const NanRespondToDataPathIndicationRequest & msg,respondToDataPathIndicationRequest_cb hidl_status_cb)685 Return<void> WifiNanIface::respondToDataPathIndicationRequest(
686 uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg,
687 respondToDataPathIndicationRequest_cb hidl_status_cb) {
688 return validateAndCall(
689 this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
690 &WifiNanIface::respondToDataPathIndicationRequestInternal,
691 hidl_status_cb, cmd_id, msg);
692 }
693
terminateDataPathRequest(uint16_t cmd_id,uint32_t ndpInstanceId,terminateDataPathRequest_cb hidl_status_cb)694 Return<void> WifiNanIface::terminateDataPathRequest(
695 uint16_t cmd_id, uint32_t ndpInstanceId,
696 terminateDataPathRequest_cb hidl_status_cb) {
697 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
698 &WifiNanIface::terminateDataPathRequestInternal,
699 hidl_status_cb, cmd_id, ndpInstanceId);
700 }
701
registerEventCallback_1_2(const sp<V1_2::IWifiNanIfaceEventCallback> & callback,registerEventCallback_1_2_cb hidl_status_cb)702 Return<void> WifiNanIface::registerEventCallback_1_2(
703 const sp<V1_2::IWifiNanIfaceEventCallback>& callback,
704 registerEventCallback_1_2_cb hidl_status_cb) {
705 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
706 &WifiNanIface::registerEventCallback_1_2Internal,
707 hidl_status_cb, callback);
708 }
709
enableRequest_1_2(uint16_t cmd_id,const V1_0::NanEnableRequest & msg1,const V1_2::NanConfigRequestSupplemental & msg2,enableRequest_1_2_cb hidl_status_cb)710 Return<void> WifiNanIface::enableRequest_1_2(
711 uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
712 const V1_2::NanConfigRequestSupplemental& msg2,
713 enableRequest_1_2_cb hidl_status_cb) {
714 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
715 &WifiNanIface::enableRequest_1_2Internal,
716 hidl_status_cb, cmd_id, msg1, msg2);
717 }
718
configRequest_1_2(uint16_t cmd_id,const V1_0::NanConfigRequest & msg1,const V1_2::NanConfigRequestSupplemental & msg2,configRequest_1_2_cb hidl_status_cb)719 Return<void> WifiNanIface::configRequest_1_2(
720 uint16_t cmd_id, const V1_0::NanConfigRequest& msg1,
721 const V1_2::NanConfigRequestSupplemental& msg2,
722 configRequest_1_2_cb hidl_status_cb) {
723 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
724 &WifiNanIface::configRequest_1_2Internal,
725 hidl_status_cb, cmd_id, msg1, msg2);
726 }
727
enableRequest_1_4(uint16_t cmd_id,const V1_4::NanEnableRequest & msg1,const V1_2::NanConfigRequestSupplemental & msg2,enableRequest_1_4_cb hidl_status_cb)728 Return<void> WifiNanIface::enableRequest_1_4(
729 uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
730 const V1_2::NanConfigRequestSupplemental& msg2,
731 enableRequest_1_4_cb hidl_status_cb) {
732 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
733 &WifiNanIface::enableRequest_1_4Internal,
734 hidl_status_cb, cmd_id, msg1, msg2);
735 }
736
configRequest_1_4(uint16_t cmd_id,const V1_4::NanConfigRequest & msg1,const V1_2::NanConfigRequestSupplemental & msg2,configRequest_1_4_cb hidl_status_cb)737 Return<void> WifiNanIface::configRequest_1_4(
738 uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
739 const V1_2::NanConfigRequestSupplemental& msg2,
740 configRequest_1_4_cb hidl_status_cb) {
741 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
742 &WifiNanIface::configRequest_1_4Internal,
743 hidl_status_cb, cmd_id, msg1, msg2);
744 }
745
registerEventCallback_1_5(const sp<IWifiNanIfaceEventCallback> & callback,registerEventCallback_1_5_cb hidl_status_cb)746 Return<void> WifiNanIface::registerEventCallback_1_5(
747 const sp<IWifiNanIfaceEventCallback>& callback,
748 registerEventCallback_1_5_cb hidl_status_cb) {
749 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
750 &WifiNanIface::registerEventCallback_1_5Internal,
751 hidl_status_cb, callback);
752 }
753
enableRequest_1_5(uint16_t cmd_id,const V1_4::NanEnableRequest & msg1,const NanConfigRequestSupplemental & msg2,enableRequest_1_5_cb hidl_status_cb)754 Return<void> WifiNanIface::enableRequest_1_5(
755 uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
756 const NanConfigRequestSupplemental& msg2,
757 enableRequest_1_5_cb hidl_status_cb) {
758 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
759 &WifiNanIface::enableRequest_1_5Internal,
760 hidl_status_cb, cmd_id, msg1, msg2);
761 }
762
configRequest_1_5(uint16_t cmd_id,const V1_4::NanConfigRequest & msg1,const NanConfigRequestSupplemental & msg2,configRequest_1_5_cb hidl_status_cb)763 Return<void> WifiNanIface::configRequest_1_5(
764 uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
765 const NanConfigRequestSupplemental& msg2,
766 configRequest_1_5_cb hidl_status_cb) {
767 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
768 &WifiNanIface::configRequest_1_5Internal,
769 hidl_status_cb, cmd_id, msg1, msg2);
770 }
771
getCapabilitiesRequest_1_5(uint16_t cmd_id,getCapabilitiesRequest_1_5_cb hidl_status_cb)772 Return<void> WifiNanIface::getCapabilitiesRequest_1_5(
773 uint16_t cmd_id, getCapabilitiesRequest_1_5_cb hidl_status_cb) {
774 return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
775 &WifiNanIface::getCapabilitiesRequest_1_5Internal,
776 hidl_status_cb, cmd_id);
777 }
778
getNameInternal()779 std::pair<WifiStatus, std::string> WifiNanIface::getNameInternal() {
780 return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
781 }
782
getTypeInternal()783 std::pair<WifiStatus, IfaceType> WifiNanIface::getTypeInternal() {
784 return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::NAN};
785 }
786
registerEventCallbackInternal(const sp<V1_0::IWifiNanIfaceEventCallback> & callback)787 WifiStatus WifiNanIface::registerEventCallbackInternal(
788 const sp<V1_0::IWifiNanIfaceEventCallback>& callback) {
789 if (!event_cb_handler_.addCallback(callback)) {
790 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
791 }
792 return createWifiStatus(WifiStatusCode::SUCCESS);
793 }
794
getCapabilitiesRequestInternal(uint16_t)795 WifiStatus WifiNanIface::getCapabilitiesRequestInternal(uint16_t /* cmd_id */) {
796 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
797 }
798
enableRequestInternal(uint16_t,const V1_0::NanEnableRequest &)799 WifiStatus WifiNanIface::enableRequestInternal(
800 uint16_t /* cmd_id */, const V1_0::NanEnableRequest& /* msg */) {
801 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
802 }
803
configRequestInternal(uint16_t,const V1_0::NanConfigRequest &)804 WifiStatus WifiNanIface::configRequestInternal(
805 uint16_t /* cmd_id */, const V1_0::NanConfigRequest& /* msg */) {
806 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
807 }
808
disableRequestInternal(uint16_t cmd_id)809 WifiStatus WifiNanIface::disableRequestInternal(uint16_t cmd_id) {
810 legacy_hal::wifi_error legacy_status =
811 legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id);
812 return createWifiStatusFromLegacyError(legacy_status);
813 }
814
startPublishRequestInternal(uint16_t cmd_id,const NanPublishRequest & msg)815 WifiStatus WifiNanIface::startPublishRequestInternal(
816 uint16_t cmd_id, const NanPublishRequest& msg) {
817 legacy_hal::NanPublishRequest legacy_msg;
818 if (!hidl_struct_util::convertHidlNanPublishRequestToLegacy(msg,
819 &legacy_msg)) {
820 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
821 }
822 legacy_hal::wifi_error legacy_status =
823 legacy_hal_.lock()->nanPublishRequest(ifname_, cmd_id, legacy_msg);
824 return createWifiStatusFromLegacyError(legacy_status);
825 }
826
stopPublishRequestInternal(uint16_t cmd_id,uint8_t sessionId)827 WifiStatus WifiNanIface::stopPublishRequestInternal(uint16_t cmd_id,
828 uint8_t sessionId) {
829 legacy_hal::NanPublishCancelRequest legacy_msg;
830 legacy_msg.publish_id = sessionId;
831 legacy_hal::wifi_error legacy_status =
832 legacy_hal_.lock()->nanPublishCancelRequest(ifname_, cmd_id,
833 legacy_msg);
834 return createWifiStatusFromLegacyError(legacy_status);
835 }
836
startSubscribeRequestInternal(uint16_t cmd_id,const NanSubscribeRequest & msg)837 WifiStatus WifiNanIface::startSubscribeRequestInternal(
838 uint16_t cmd_id, const NanSubscribeRequest& msg) {
839 legacy_hal::NanSubscribeRequest legacy_msg;
840 if (!hidl_struct_util::convertHidlNanSubscribeRequestToLegacy(
841 msg, &legacy_msg)) {
842 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
843 }
844 legacy_hal::wifi_error legacy_status =
845 legacy_hal_.lock()->nanSubscribeRequest(ifname_, cmd_id, legacy_msg);
846 return createWifiStatusFromLegacyError(legacy_status);
847 }
848
stopSubscribeRequestInternal(uint16_t cmd_id,uint8_t sessionId)849 WifiStatus WifiNanIface::stopSubscribeRequestInternal(uint16_t cmd_id,
850 uint8_t sessionId) {
851 legacy_hal::NanSubscribeCancelRequest legacy_msg;
852 legacy_msg.subscribe_id = sessionId;
853 legacy_hal::wifi_error legacy_status =
854 legacy_hal_.lock()->nanSubscribeCancelRequest(ifname_, cmd_id,
855 legacy_msg);
856 return createWifiStatusFromLegacyError(legacy_status);
857 }
858
transmitFollowupRequestInternal(uint16_t cmd_id,const NanTransmitFollowupRequest & msg)859 WifiStatus WifiNanIface::transmitFollowupRequestInternal(
860 uint16_t cmd_id, const NanTransmitFollowupRequest& msg) {
861 legacy_hal::NanTransmitFollowupRequest legacy_msg;
862 if (!hidl_struct_util::convertHidlNanTransmitFollowupRequestToLegacy(
863 msg, &legacy_msg)) {
864 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
865 }
866 legacy_hal::wifi_error legacy_status =
867 legacy_hal_.lock()->nanTransmitFollowupRequest(ifname_, cmd_id,
868 legacy_msg);
869 return createWifiStatusFromLegacyError(legacy_status);
870 }
871
createDataInterfaceRequestInternal(uint16_t cmd_id,const std::string & iface_name)872 WifiStatus WifiNanIface::createDataInterfaceRequestInternal(
873 uint16_t cmd_id, const std::string& iface_name) {
874 legacy_hal::wifi_error legacy_status =
875 legacy_hal_.lock()->nanDataInterfaceCreate(ifname_, cmd_id, iface_name);
876 return createWifiStatusFromLegacyError(legacy_status);
877 }
deleteDataInterfaceRequestInternal(uint16_t cmd_id,const std::string & iface_name)878 WifiStatus WifiNanIface::deleteDataInterfaceRequestInternal(
879 uint16_t cmd_id, const std::string& iface_name) {
880 legacy_hal::wifi_error legacy_status =
881 legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, cmd_id, iface_name);
882 return createWifiStatusFromLegacyError(legacy_status);
883 }
initiateDataPathRequestInternal(uint16_t cmd_id,const NanInitiateDataPathRequest & msg)884 WifiStatus WifiNanIface::initiateDataPathRequestInternal(
885 uint16_t cmd_id, const NanInitiateDataPathRequest& msg) {
886 legacy_hal::NanDataPathInitiatorRequest legacy_msg;
887 if (!hidl_struct_util::convertHidlNanDataPathInitiatorRequestToLegacy(
888 msg, &legacy_msg)) {
889 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
890 }
891 legacy_hal::wifi_error legacy_status =
892 legacy_hal_.lock()->nanDataRequestInitiator(ifname_, cmd_id,
893 legacy_msg);
894 return createWifiStatusFromLegacyError(legacy_status);
895 }
respondToDataPathIndicationRequestInternal(uint16_t cmd_id,const NanRespondToDataPathIndicationRequest & msg)896 WifiStatus WifiNanIface::respondToDataPathIndicationRequestInternal(
897 uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) {
898 legacy_hal::NanDataPathIndicationResponse legacy_msg;
899 if (!hidl_struct_util::convertHidlNanDataPathIndicationResponseToLegacy(
900 msg, &legacy_msg)) {
901 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
902 }
903 legacy_hal::wifi_error legacy_status =
904 legacy_hal_.lock()->nanDataIndicationResponse(ifname_, cmd_id,
905 legacy_msg);
906 return createWifiStatusFromLegacyError(legacy_status);
907 }
terminateDataPathRequestInternal(uint16_t cmd_id,uint32_t ndpInstanceId)908 WifiStatus WifiNanIface::terminateDataPathRequestInternal(
909 uint16_t cmd_id, uint32_t ndpInstanceId) {
910 legacy_hal::wifi_error legacy_status =
911 legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId);
912 return createWifiStatusFromLegacyError(legacy_status);
913 }
914
registerEventCallback_1_2Internal(const sp<V1_2::IWifiNanIfaceEventCallback> & callback)915 WifiStatus WifiNanIface::registerEventCallback_1_2Internal(
916 const sp<V1_2::IWifiNanIfaceEventCallback>& callback) {
917 sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback;
918 if (!event_cb_handler_.addCallback(callback_1_0)) {
919 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
920 }
921 if (!event_cb_handler_1_2_.addCallback(callback)) {
922 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
923 }
924 return createWifiStatus(WifiStatusCode::SUCCESS);
925 }
926
enableRequest_1_2Internal(uint16_t,const V1_0::NanEnableRequest &,const V1_2::NanConfigRequestSupplemental &)927 WifiStatus WifiNanIface::enableRequest_1_2Internal(
928 uint16_t /* cmd_id */, const V1_0::NanEnableRequest& /* msg1 */,
929 const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
930 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
931 }
932
configRequest_1_2Internal(uint16_t,const V1_0::NanConfigRequest &,const V1_2::NanConfigRequestSupplemental &)933 WifiStatus WifiNanIface::configRequest_1_2Internal(
934 uint16_t /* cmd_id */, const V1_0::NanConfigRequest& /* msg1 */,
935 const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
936 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
937 }
938
enableRequest_1_4Internal(uint16_t,const V1_4::NanEnableRequest &,const V1_2::NanConfigRequestSupplemental &)939 WifiStatus WifiNanIface::enableRequest_1_4Internal(
940 uint16_t /* cmd_id */, const V1_4::NanEnableRequest& /* msg1 */,
941 const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
942 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
943 }
944
configRequest_1_4Internal(uint16_t,const V1_4::NanConfigRequest &,const V1_2::NanConfigRequestSupplemental &)945 WifiStatus WifiNanIface::configRequest_1_4Internal(
946 uint16_t /* cmd_id */, const V1_4::NanConfigRequest& /* msg1 */,
947 const V1_2::NanConfigRequestSupplemental& /* msg2 */) {
948 return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
949 }
950
registerEventCallback_1_5Internal(const sp<IWifiNanIfaceEventCallback> & callback)951 WifiStatus WifiNanIface::registerEventCallback_1_5Internal(
952 const sp<IWifiNanIfaceEventCallback>& callback) {
953 sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback;
954 if (!event_cb_handler_.addCallback(callback_1_0)) {
955 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
956 }
957 sp<V1_2::IWifiNanIfaceEventCallback> callback_1_2 = callback;
958 if (!event_cb_handler_1_2_.addCallback(callback_1_2)) {
959 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
960 }
961 if (!event_cb_handler_1_5_.addCallback(callback)) {
962 return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
963 }
964 return createWifiStatus(WifiStatusCode::SUCCESS);
965 }
966
getCapabilitiesRequest_1_5Internal(uint16_t cmd_id)967 WifiStatus WifiNanIface::getCapabilitiesRequest_1_5Internal(uint16_t cmd_id) {
968 legacy_hal::wifi_error legacy_status =
969 legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id);
970 return createWifiStatusFromLegacyError(legacy_status);
971 }
972
enableRequest_1_5Internal(uint16_t cmd_id,const V1_4::NanEnableRequest & msg1,const NanConfigRequestSupplemental & msg2)973 WifiStatus WifiNanIface::enableRequest_1_5Internal(
974 uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
975 const NanConfigRequestSupplemental& msg2) {
976 legacy_hal::NanEnableRequest legacy_msg;
977 if (!hidl_struct_util::convertHidlNanEnableRequest_1_5ToLegacy(
978 msg1, msg2, &legacy_msg)) {
979 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
980 }
981 legacy_hal::wifi_error legacy_status =
982 legacy_hal_.lock()->nanEnableRequest(ifname_, cmd_id, legacy_msg);
983 return createWifiStatusFromLegacyError(legacy_status);
984 }
985
configRequest_1_5Internal(uint16_t cmd_id,const V1_4::NanConfigRequest & msg1,const NanConfigRequestSupplemental & msg2)986 WifiStatus WifiNanIface::configRequest_1_5Internal(
987 uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
988 const NanConfigRequestSupplemental& msg2) {
989 legacy_hal::NanConfigRequest legacy_msg;
990 if (!hidl_struct_util::convertHidlNanConfigRequest_1_5ToLegacy(
991 msg1, msg2, &legacy_msg)) {
992 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
993 }
994 legacy_hal::wifi_error legacy_status =
995 legacy_hal_.lock()->nanConfigRequest(ifname_, cmd_id, legacy_msg);
996 return createWifiStatusFromLegacyError(legacy_status);
997 }
998
999 } // namespace implementation
1000 } // namespace V1_5
1001 } // namespace wifi
1002 } // namespace hardware
1003 } // namespace android
1004