| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <android-base/logging.h> |
| |
| #include "hidl_return_util.h" |
| #include "hidl_struct_util.h" |
| #include "wifi_nan_iface.h" |
| #include "wifi_status_util.h" |
| |
| namespace android { |
| namespace hardware { |
| namespace wifi { |
| namespace V1_3 { |
| namespace implementation { |
| using hidl_return_util::validateAndCall; |
| |
| WifiNanIface::WifiNanIface( |
| const std::string& ifname, |
| const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal, |
| const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util) |
| : ifname_(ifname), |
| legacy_hal_(legacy_hal), |
| iface_util_(iface_util), |
| is_valid_(true) { |
| // Register all the callbacks here. these should be valid for the lifetime |
| // of the object. Whenever the mode changes legacy HAL will remove |
| // all of these callbacks. |
| legacy_hal::NanCallbackHandlers callback_handlers; |
| android::wp<WifiNanIface> weak_ptr_this(this); |
| |
| // Callback for response. |
| callback_handlers |
| .on_notify_response = [weak_ptr_this]( |
| legacy_hal::transaction_id id, |
| const legacy_hal::NanResponseMsg& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| WifiNanStatus wifiNanStatus; |
| if (!hidl_struct_util::convertLegacyNanResponseHeaderToHidl( |
| msg, &wifiNanStatus)) { |
| LOG(ERROR) << "Failed to convert nan response header"; |
| return; |
| } |
| |
| switch (msg.response_type) { |
| case legacy_hal::NAN_RESPONSE_ENABLED: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback->notifyEnableResponse(id, wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_DISABLED: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback->notifyDisableResponse(id, wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_PUBLISH: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyStartPublishResponse( |
| id, wifiNanStatus, |
| msg.body.publish_response.publish_id) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback->notifyStopPublishResponse(id, wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyTransmitFollowupResponse(id, wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_SUBSCRIBE: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyStartSubscribeResponse( |
| id, wifiNanStatus, |
| msg.body.subscribe_response.subscribe_id) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyStopSubscribeResponse(id, wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_CONFIG: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback->notifyConfigResponse(id, wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_GET_CAPABILITIES: { |
| NanCapabilities hidl_struct; |
| if (!hidl_struct_util:: |
| convertLegacyNanCapabilitiesResponseToHidl( |
| msg.body.nan_capabilities, &hidl_struct)) { |
| LOG(ERROR) << "Failed to convert nan capabilities response"; |
| return; |
| } |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyCapabilitiesResponse(id, wifiNanStatus, |
| hidl_struct) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_DP_INTERFACE_CREATE: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyCreateDataInterfaceResponse(id, |
| wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_DP_INTERFACE_DELETE: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyDeleteDataInterfaceResponse(id, |
| wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_DP_INITIATOR_RESPONSE: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyInitiateDataPathResponse( |
| id, wifiNanStatus, |
| msg.body.data_request_response.ndp_instance_id) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_DP_RESPONDER_RESPONSE: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyRespondToDataPathIndicationResponse( |
| id, wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_DP_END: { |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->notifyTerminateDataPathResponse(id, |
| wifiNanStatus) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| break; |
| } |
| case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD: |
| /* fall through */ |
| case legacy_hal::NAN_RESPONSE_TCA: |
| /* fall through */ |
| case legacy_hal::NAN_RESPONSE_STATS: |
| /* fall through */ |
| case legacy_hal::NAN_RESPONSE_ERROR: |
| /* fall through */ |
| default: |
| LOG(ERROR) << "Unknown or unhandled response type: " |
| << msg.response_type; |
| return; |
| } |
| }; |
| |
| callback_handlers.on_event_disc_eng_event = |
| [weak_ptr_this](const legacy_hal::NanDiscEngEventInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| NanClusterEventInd hidl_struct; |
| // event types defined identically - hence can be cast |
| hidl_struct.eventType = (NanClusterEventType)msg.event_type; |
| hidl_struct.addr = msg.data.mac_addr.addr; |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventClusterEvent(hidl_struct).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_disabled = |
| [weak_ptr_this](const legacy_hal::NanDisabledInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| WifiNanStatus status; |
| hidl_struct_util::convertToWifiNanStatus( |
| msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status); |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventDisabled(status).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_publish_terminated = |
| [weak_ptr_this](const legacy_hal::NanPublishTerminatedInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| WifiNanStatus status; |
| hidl_struct_util::convertToWifiNanStatus( |
| msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status); |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventPublishTerminated(msg.publish_id, status) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_subscribe_terminated = |
| [weak_ptr_this](const legacy_hal::NanSubscribeTerminatedInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| WifiNanStatus status; |
| hidl_struct_util::convertToWifiNanStatus( |
| msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status); |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->eventSubscribeTerminated(msg.subscribe_id, status) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_match = |
| [weak_ptr_this](const legacy_hal::NanMatchInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| NanMatchInd hidl_struct; |
| if (!hidl_struct_util::convertLegacyNanMatchIndToHidl( |
| msg, &hidl_struct)) { |
| LOG(ERROR) << "Failed to convert nan capabilities response"; |
| return; |
| } |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventMatch(hidl_struct).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_match_expired = |
| [weak_ptr_this](const legacy_hal::NanMatchExpiredInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback |
| ->eventMatchExpired(msg.publish_subscribe_id, |
| msg.requestor_instance_id) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_followup = |
| [weak_ptr_this](const legacy_hal::NanFollowupInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| NanFollowupReceivedInd hidl_struct; |
| if (!hidl_struct_util::convertLegacyNanFollowupIndToHidl( |
| msg, &hidl_struct)) { |
| LOG(ERROR) << "Failed to convert nan capabilities response"; |
| return; |
| } |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventFollowupReceived(hidl_struct).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_transmit_follow_up = |
| [weak_ptr_this](const legacy_hal::NanTransmitFollowupInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| WifiNanStatus status; |
| hidl_struct_util::convertToWifiNanStatus( |
| msg.reason, msg.nan_reason, sizeof(msg.nan_reason), &status); |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventTransmitFollowup(msg.id, status).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_data_path_request = |
| [weak_ptr_this](const legacy_hal::NanDataPathRequestInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| NanDataPathRequestInd hidl_struct; |
| if (!hidl_struct_util::convertLegacyNanDataPathRequestIndToHidl( |
| msg, &hidl_struct)) { |
| LOG(ERROR) << "Failed to convert nan capabilities response"; |
| return; |
| } |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventDataPathRequest(hidl_struct).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_data_path_confirm = |
| [weak_ptr_this](const legacy_hal::NanDataPathConfirmInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| V1_2::NanDataPathConfirmInd hidl_struct; |
| if (!hidl_struct_util::convertLegacyNanDataPathConfirmIndToHidl( |
| msg, &hidl_struct)) { |
| LOG(ERROR) << "Failed to convert nan capabilities response"; |
| return; |
| } |
| |
| for (const auto& callback : |
| shared_ptr_this->getEventCallbacks_1_2()) { |
| if (!callback->eventDataPathConfirm_1_2(hidl_struct).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_data_path_end = |
| [weak_ptr_this](const legacy_hal::NanDataPathEndInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| for (int i = 0; i < msg.num_ndp_instances; ++i) { |
| if (!callback |
| ->eventDataPathTerminated(msg.ndp_instance_id[i]) |
| .isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| } |
| }; |
| |
| callback_handlers.on_event_beacon_sdf_payload = |
| [weak_ptr_this](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) { |
| LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called"; |
| }; |
| |
| callback_handlers.on_event_range_request = |
| [weak_ptr_this](const legacy_hal::NanRangeRequestInd& /* msg */) { |
| LOG(ERROR) << "on_event_range_request - should not be called"; |
| }; |
| |
| callback_handlers.on_event_range_report = |
| [weak_ptr_this](const legacy_hal::NanRangeReportInd& /* msg */) { |
| LOG(ERROR) << "on_event_range_report - should not be called"; |
| }; |
| |
| callback_handlers |
| .on_event_schedule_update = [weak_ptr_this]( |
| const legacy_hal:: |
| NanDataPathScheduleUpdateInd& msg) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| V1_2::NanDataPathScheduleUpdateInd hidl_struct; |
| if (!hidl_struct_util::convertLegacyNanDataPathScheduleUpdateIndToHidl( |
| msg, &hidl_struct)) { |
| LOG(ERROR) << "Failed to convert nan capabilities response"; |
| return; |
| } |
| |
| for (const auto& callback : shared_ptr_this->getEventCallbacks_1_2()) { |
| if (!callback->eventDataPathScheduleUpdate(hidl_struct).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanRegisterCallbackHandlers(ifname_, |
| callback_handlers); |
| if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| LOG(ERROR) << "Failed to register nan callbacks. Invalidating object"; |
| invalidate(); |
| } |
| |
| // Register for iface state toggle events. |
| iface_util::IfaceEventHandlers event_handlers = {}; |
| event_handlers.on_state_toggle_off_on = |
| [weak_ptr_this](const std::string& /* iface_name */) { |
| const auto shared_ptr_this = weak_ptr_this.promote(); |
| if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| LOG(ERROR) << "Callback invoked on an invalid object"; |
| return; |
| } |
| // Tell framework that NAN has been disabled. |
| WifiNanStatus status = { |
| NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""}; |
| for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
| if (!callback->eventDisabled(status).isOk()) { |
| LOG(ERROR) << "Failed to invoke the callback"; |
| } |
| } |
| }; |
| iface_util_.lock()->registerIfaceEventHandlers(ifname_, event_handlers); |
| } |
| |
| void WifiNanIface::invalidate() { |
| // send commands to HAL to actually disable and destroy interfaces |
| legacy_hal_.lock()->nanDisableRequest(ifname_, 0xFFFF); |
| legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFE, "aware_data0"); |
| legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFD, "aware_data1"); |
| iface_util_.lock()->unregisterIfaceEventHandlers(ifname_); |
| legacy_hal_.reset(); |
| event_cb_handler_.invalidate(); |
| event_cb_handler_1_2_.invalidate(); |
| is_valid_ = false; |
| } |
| |
| bool WifiNanIface::isValid() { return is_valid_; } |
| |
| std::string WifiNanIface::getName() { return ifname_; } |
| |
| std::set<sp<V1_0::IWifiNanIfaceEventCallback>> |
| WifiNanIface::getEventCallbacks() { |
| return event_cb_handler_.getCallbacks(); |
| } |
| |
| std::set<sp<V1_2::IWifiNanIfaceEventCallback>> |
| WifiNanIface::getEventCallbacks_1_2() { |
| return event_cb_handler_1_2_.getCallbacks(); |
| } |
| |
| Return<void> WifiNanIface::getName(getName_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::getNameInternal, hidl_status_cb); |
| } |
| |
| Return<void> WifiNanIface::getType(getType_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::getTypeInternal, hidl_status_cb); |
| } |
| |
| Return<void> WifiNanIface::registerEventCallback( |
| const sp<V1_0::IWifiNanIfaceEventCallback>& callback, |
| registerEventCallback_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::registerEventCallbackInternal, |
| hidl_status_cb, callback); |
| } |
| |
| Return<void> WifiNanIface::getCapabilitiesRequest( |
| uint16_t cmd_id, getCapabilitiesRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::getCapabilitiesRequestInternal, |
| hidl_status_cb, cmd_id); |
| } |
| |
| Return<void> WifiNanIface::enableRequest(uint16_t cmd_id, |
| const NanEnableRequest& msg, |
| enableRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::enableRequestInternal, hidl_status_cb, |
| cmd_id, msg); |
| } |
| |
| Return<void> WifiNanIface::configRequest(uint16_t cmd_id, |
| const NanConfigRequest& msg, |
| configRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::configRequestInternal, hidl_status_cb, |
| cmd_id, msg); |
| } |
| |
| Return<void> WifiNanIface::disableRequest(uint16_t cmd_id, |
| disableRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::disableRequestInternal, |
| hidl_status_cb, cmd_id); |
| } |
| |
| Return<void> WifiNanIface::startPublishRequest( |
| uint16_t cmd_id, const NanPublishRequest& msg, |
| startPublishRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::startPublishRequestInternal, |
| hidl_status_cb, cmd_id, msg); |
| } |
| |
| Return<void> WifiNanIface::stopPublishRequest( |
| uint16_t cmd_id, uint8_t sessionId, stopPublishRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::stopPublishRequestInternal, |
| hidl_status_cb, cmd_id, sessionId); |
| } |
| |
| Return<void> WifiNanIface::startSubscribeRequest( |
| uint16_t cmd_id, const NanSubscribeRequest& msg, |
| startSubscribeRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::startSubscribeRequestInternal, |
| hidl_status_cb, cmd_id, msg); |
| } |
| |
| Return<void> WifiNanIface::stopSubscribeRequest( |
| uint16_t cmd_id, uint8_t sessionId, |
| stopSubscribeRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::stopSubscribeRequestInternal, |
| hidl_status_cb, cmd_id, sessionId); |
| } |
| |
| Return<void> WifiNanIface::transmitFollowupRequest( |
| uint16_t cmd_id, const NanTransmitFollowupRequest& msg, |
| transmitFollowupRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::transmitFollowupRequestInternal, |
| hidl_status_cb, cmd_id, msg); |
| } |
| |
| Return<void> WifiNanIface::createDataInterfaceRequest( |
| uint16_t cmd_id, const hidl_string& iface_name, |
| createDataInterfaceRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::createDataInterfaceRequestInternal, |
| hidl_status_cb, cmd_id, iface_name); |
| } |
| |
| Return<void> WifiNanIface::deleteDataInterfaceRequest( |
| uint16_t cmd_id, const hidl_string& iface_name, |
| deleteDataInterfaceRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::deleteDataInterfaceRequestInternal, |
| hidl_status_cb, cmd_id, iface_name); |
| } |
| |
| Return<void> WifiNanIface::initiateDataPathRequest( |
| uint16_t cmd_id, const NanInitiateDataPathRequest& msg, |
| initiateDataPathRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::initiateDataPathRequestInternal, |
| hidl_status_cb, cmd_id, msg); |
| } |
| |
| Return<void> WifiNanIface::respondToDataPathIndicationRequest( |
| uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg, |
| respondToDataPathIndicationRequest_cb hidl_status_cb) { |
| return validateAndCall( |
| this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::respondToDataPathIndicationRequestInternal, |
| hidl_status_cb, cmd_id, msg); |
| } |
| |
| Return<void> WifiNanIface::terminateDataPathRequest( |
| uint16_t cmd_id, uint32_t ndpInstanceId, |
| terminateDataPathRequest_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::terminateDataPathRequestInternal, |
| hidl_status_cb, cmd_id, ndpInstanceId); |
| } |
| |
| Return<void> WifiNanIface::registerEventCallback_1_2( |
| const sp<V1_2::IWifiNanIfaceEventCallback>& callback, |
| registerEventCallback_1_2_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::registerEventCallback_1_2Internal, |
| hidl_status_cb, callback); |
| } |
| |
| Return<void> WifiNanIface::enableRequest_1_2( |
| uint16_t cmd_id, const NanEnableRequest& msg1, |
| const V1_2::NanConfigRequestSupplemental& msg2, |
| enableRequest_1_2_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::enableRequest_1_2Internal, |
| hidl_status_cb, cmd_id, msg1, msg2); |
| } |
| |
| Return<void> WifiNanIface::configRequest_1_2( |
| uint16_t cmd_id, const NanConfigRequest& msg1, |
| const V1_2::NanConfigRequestSupplemental& msg2, |
| configRequest_1_2_cb hidl_status_cb) { |
| return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| &WifiNanIface::configRequest_1_2Internal, |
| hidl_status_cb, cmd_id, msg1, msg2); |
| } |
| |
| std::pair<WifiStatus, std::string> WifiNanIface::getNameInternal() { |
| return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_}; |
| } |
| |
| std::pair<WifiStatus, IfaceType> WifiNanIface::getTypeInternal() { |
| return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::NAN}; |
| } |
| |
| WifiStatus WifiNanIface::registerEventCallbackInternal( |
| const sp<V1_0::IWifiNanIfaceEventCallback>& callback) { |
| if (!event_cb_handler_.addCallback(callback)) { |
| return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); |
| } |
| return createWifiStatus(WifiStatusCode::SUCCESS); |
| } |
| |
| WifiStatus WifiNanIface::getCapabilitiesRequestInternal(uint16_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::enableRequestInternal( |
| uint16_t /* cmd_id */, const NanEnableRequest& /* msg */) { |
| return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED); |
| } |
| |
| WifiStatus WifiNanIface::configRequestInternal( |
| uint16_t /* cmd_id */, const NanConfigRequest& /* msg */) { |
| return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED); |
| } |
| |
| WifiStatus WifiNanIface::disableRequestInternal(uint16_t cmd_id) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::startPublishRequestInternal( |
| uint16_t cmd_id, const NanPublishRequest& msg) { |
| legacy_hal::NanPublishRequest legacy_msg; |
| if (!hidl_struct_util::convertHidlNanPublishRequestToLegacy(msg, |
| &legacy_msg)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanPublishRequest(ifname_, cmd_id, legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::stopPublishRequestInternal(uint16_t cmd_id, |
| uint8_t sessionId) { |
| legacy_hal::NanPublishCancelRequest legacy_msg; |
| legacy_msg.publish_id = sessionId; |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanPublishCancelRequest(ifname_, cmd_id, |
| legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::startSubscribeRequestInternal( |
| uint16_t cmd_id, const NanSubscribeRequest& msg) { |
| legacy_hal::NanSubscribeRequest legacy_msg; |
| if (!hidl_struct_util::convertHidlNanSubscribeRequestToLegacy( |
| msg, &legacy_msg)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanSubscribeRequest(ifname_, cmd_id, legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::stopSubscribeRequestInternal(uint16_t cmd_id, |
| uint8_t sessionId) { |
| legacy_hal::NanSubscribeCancelRequest legacy_msg; |
| legacy_msg.subscribe_id = sessionId; |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanSubscribeCancelRequest(ifname_, cmd_id, |
| legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::transmitFollowupRequestInternal( |
| uint16_t cmd_id, const NanTransmitFollowupRequest& msg) { |
| legacy_hal::NanTransmitFollowupRequest legacy_msg; |
| if (!hidl_struct_util::convertHidlNanTransmitFollowupRequestToLegacy( |
| msg, &legacy_msg)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanTransmitFollowupRequest(ifname_, cmd_id, |
| legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::createDataInterfaceRequestInternal( |
| uint16_t cmd_id, const std::string& iface_name) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanDataInterfaceCreate(ifname_, cmd_id, iface_name); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| WifiStatus WifiNanIface::deleteDataInterfaceRequestInternal( |
| uint16_t cmd_id, const std::string& iface_name) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, cmd_id, iface_name); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| WifiStatus WifiNanIface::initiateDataPathRequestInternal( |
| uint16_t cmd_id, const NanInitiateDataPathRequest& msg) { |
| legacy_hal::NanDataPathInitiatorRequest legacy_msg; |
| if (!hidl_struct_util::convertHidlNanDataPathInitiatorRequestToLegacy( |
| msg, &legacy_msg)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanDataRequestInitiator(ifname_, cmd_id, |
| legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| WifiStatus WifiNanIface::respondToDataPathIndicationRequestInternal( |
| uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) { |
| legacy_hal::NanDataPathIndicationResponse legacy_msg; |
| if (!hidl_struct_util::convertHidlNanDataPathIndicationResponseToLegacy( |
| msg, &legacy_msg)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanDataIndicationResponse(ifname_, cmd_id, |
| legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| WifiStatus WifiNanIface::terminateDataPathRequestInternal( |
| uint16_t cmd_id, uint32_t ndpInstanceId) { |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::registerEventCallback_1_2Internal( |
| const sp<V1_2::IWifiNanIfaceEventCallback>& callback) { |
| sp<V1_0::IWifiNanIfaceEventCallback> callback_1_0 = callback; |
| if (!event_cb_handler_.addCallback(callback_1_0)) { |
| return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); |
| } |
| if (!event_cb_handler_1_2_.addCallback(callback)) { |
| return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); |
| } |
| return createWifiStatus(WifiStatusCode::SUCCESS); |
| } |
| |
| WifiStatus WifiNanIface::enableRequest_1_2Internal( |
| uint16_t cmd_id, const NanEnableRequest& msg1, |
| const V1_2::NanConfigRequestSupplemental& msg2) { |
| legacy_hal::NanEnableRequest legacy_msg; |
| if (!hidl_struct_util::convertHidlNanEnableRequest_1_2ToLegacy( |
| msg1, msg2, &legacy_msg)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanEnableRequest(ifname_, cmd_id, legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| WifiStatus WifiNanIface::configRequest_1_2Internal( |
| uint16_t cmd_id, const NanConfigRequest& msg1, |
| const V1_2::NanConfigRequestSupplemental& msg2) { |
| legacy_hal::NanConfigRequest legacy_msg; |
| if (!hidl_struct_util::convertHidlNanConfigRequest_1_2ToLegacy( |
| msg1, msg2, &legacy_msg)) { |
| return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| } |
| legacy_hal::wifi_error legacy_status = |
| legacy_hal_.lock()->nanConfigRequest(ifname_, cmd_id, legacy_msg); |
| return createWifiStatusFromLegacyError(legacy_status); |
| } |
| |
| } // namespace implementation |
| } // namespace V1_3 |
| } // namespace wifi |
| } // namespace hardware |
| } // namespace android |