wifi/aidl/default/wifi_nan_iface.cpp

/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "wifi_nan_iface.h"

#include <android-base/logging.h>

#include "aidl_return_util.h"
#include "aidl_struct_util.h"
#include "wifi_status_util.h"

namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
using aidl_return_util::validateAndCall;

WifiNanIface::WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
                           const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
                           const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
    : ifname_(ifname),
      is_dedicated_iface_(is_dedicated_iface),
      legacy_hal_(legacy_hal),
      iface_util_(iface_util),
      is_valid_(true) {}

std::shared_ptr<WifiNanIface> WifiNanIface::create(
        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) {
    std::shared_ptr<WifiNanIface> ptr = ndk::SharedRefBase::make<WifiNanIface>(
            ifname, is_dedicated_iface, legacy_hal, iface_util);
    if (is_dedicated_iface) {
        // If using a dedicated iface, set the iface up first.
        if (!iface_util.lock()->setUpState(ifname, true)) {
            // Fatal failure, invalidate the iface object.
            ptr->invalidate();
            return nullptr;
        }
    }
    std::weak_ptr<WifiNanIface> weak_ptr_this(ptr);
    ptr->setWeakPtr(weak_ptr_this);
    ptr->registerCallbackHandlers();
    return ptr;
}

void WifiNanIface::registerCallbackHandlers() {
    // 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;
    std::weak_ptr<WifiNanIface> weak_ptr_this = weak_ptr_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.lock();
        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
            LOG(ERROR) << "Callback invoked on an invalid object";
            return;
        }
        NanStatus nanStatus;
        if (!aidl_struct_util::convertLegacyNanResponseHeaderToAidl(msg, &nanStatus)) {
            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, nanStatus).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, nanStatus).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, nanStatus,
                                                              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, nanStatus).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, nanStatus).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, nanStatus, 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, nanStatus).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, nanStatus).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_GET_CAPABILITIES: {
                NanCapabilities aidl_struct;
                if (!aidl_struct_util::convertLegacyNanCapabilitiesResponseToAidl(
                            msg.body.nan_capabilities, &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifyCapabilitiesResponse(id, nanStatus, aidl_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, nanStatus).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, nanStatus).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, nanStatus,
                                         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, nanStatus)
                                 .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, nanStatus).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_PAIRING_INITIATOR_RESPONSE: {
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifyInitiatePairingResponse(
                                         id, nanStatus,
                                         msg.body.pairing_request_response.paring_instance_id)
                                 .isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_PAIRING_RESPONDER_RESPONSE: {
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifyRespondToPairingIndicationResponse(id, nanStatus).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_PAIRING_END: {
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifyTerminatePairingResponse(id, nanStatus).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_BOOTSTRAPPING_INITIATOR_RESPONSE: {
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifyInitiateBootstrappingResponse(
                                         id, nanStatus,
                                         msg.body.bootstrapping_request_response
                                                 .bootstrapping_instance_id)
                                 .isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_BOOTSTRAPPING_RESPONDER_RESPONSE: {
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifyRespondToBootstrappingIndicationResponse(id, nanStatus)
                                 .isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_SUSPEND_REQUEST_RESPONSE: {
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifySuspendResponse(id, nanStatus).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
                break;
            }
            case legacy_hal::NAN_RESUME_REQUEST_RESPONSE: {
                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->notifyResumeResponse(id, nanStatus).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.lock();
        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
            LOG(ERROR) << "Callback invoked on an invalid object";
            return;
        }
        NanClusterEventInd aidl_struct;
        // event types defined identically - hence can be cast
        aidl_struct.eventType = (NanClusterEventType)msg.event_type;
        aidl_struct.addr = std::array<uint8_t, 6>();
        std::copy(msg.data.mac_addr.addr, msg.data.mac_addr.addr + 6, std::begin(aidl_struct.addr));

        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
            if (!callback->eventClusterEvent(aidl_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.lock();
        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
            LOG(ERROR) << "Callback invoked on an invalid object";
            return;
        }
        NanStatus status;
        aidl_struct_util::convertToNanStatus(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.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanStatus status;
                aidl_struct_util::convertToNanStatus(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.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanStatus status;
                aidl_struct_util::convertToNanStatus(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.lock();
        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
            LOG(ERROR) << "Callback invoked on an invalid object";
            return;
        }
        NanMatchInd aidl_struct;
        if (!aidl_struct_util::convertLegacyNanMatchIndToAidl(msg, &aidl_struct)) {
            LOG(ERROR) << "Failed to convert nan capabilities response";
            return;
        }

        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
            if (!callback->eventMatch(aidl_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.lock();
        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.lock();
        if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
            LOG(ERROR) << "Callback invoked on an invalid object";
            return;
        }
        NanFollowupReceivedInd aidl_struct;
        if (!aidl_struct_util::convertLegacyNanFollowupIndToAidl(msg, &aidl_struct)) {
            LOG(ERROR) << "Failed to convert nan capabilities response";
            return;
        }

        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
            if (!callback->eventFollowupReceived(aidl_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.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanStatus status;
                aidl_struct_util::convertToNanStatus(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.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanDataPathRequestInd aidl_struct;
                if (!aidl_struct_util::convertLegacyNanDataPathRequestIndToAidl(msg,
                                                                                &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventDataPathRequest(aidl_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.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanDataPathConfirmInd aidl_struct;
                if (!aidl_struct_util::convertLegacyNanDataPathConfirmIndToAidl(msg,
                                                                                &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventDataPathConfirm(aidl_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.lock();
                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_pairing_request =
            [weak_ptr_this](const legacy_hal::NanPairingRequestInd& msg) {
                const auto shared_ptr_this = weak_ptr_this.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanPairingRequestInd aidl_struct;
                if (!aidl_struct_util::convertLegacyNanPairingRequestIndToAidl(msg, &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventPairingRequest(aidl_struct).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
            };
    callback_handlers.on_event_pairing_confirm =
            [weak_ptr_this](const legacy_hal::NanPairingConfirmInd& msg) {
                const auto shared_ptr_this = weak_ptr_this.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanPairingConfirmInd aidl_struct;
                if (!aidl_struct_util::convertLegacyNanPairingConfirmIndToAidl(msg, &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventPairingConfirm(aidl_struct).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
            };
    callback_handlers.on_event_bootstrapping_request =
            [weak_ptr_this](const legacy_hal::NanBootstrappingRequestInd& msg) {
                const auto shared_ptr_this = weak_ptr_this.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanBootstrappingRequestInd aidl_struct;
                if (!aidl_struct_util::convertLegacyNanBootstrappingRequestIndToAidl(
                            msg, &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventBootstrappingRequest(aidl_struct).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
            };
    callback_handlers.on_event_bootstrapping_confirm =
            [weak_ptr_this](const legacy_hal::NanBootstrappingConfirmInd& msg) {
                const auto shared_ptr_this = weak_ptr_this.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanBootstrappingConfirmInd aidl_struct;
                if (!aidl_struct_util::convertLegacyNanBootstrappingConfirmIndToAidl(
                            msg, &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventBootstrappingConfirm(aidl_struct).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
            };

    callback_handlers.on_event_beacon_sdf_payload =
            [](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) {
                LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called";
            };

    callback_handlers.on_event_range_request = [](const legacy_hal::NanRangeRequestInd& /* msg */) {
        LOG(ERROR) << "on_event_range_request - should not be called";
    };

    callback_handlers.on_event_range_report = [](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.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanDataPathScheduleUpdateInd aidl_struct;
                if (!aidl_struct_util::convertLegacyNanDataPathScheduleUpdateIndToAidl(
                            msg, &aidl_struct)) {
                    LOG(ERROR) << "Failed to convert nan capabilities response";
                    return;
                }

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventDataPathScheduleUpdate(aidl_struct).isOk()) {
                        LOG(ERROR) << "Failed to invoke the callback";
                    }
                }
            };
    callback_handlers.on_event_suspension_mode_change =
            [weak_ptr_this](const legacy_hal::NanSuspensionModeChangeInd& msg) {
                const auto shared_ptr_this = weak_ptr_this.lock();
                if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
                    LOG(ERROR) << "Callback invoked on an invalid object";
                    return;
                }
                NanSuspensionModeChangeInd aidl_struct;
                aidl_struct.isSuspended = msg.is_suspended;

                for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
                    if (!callback->eventSuspensionModeChanged(aidl_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 = {};
#ifndef WIFI_SKIP_STATE_TOGGLE_OFF_ON_FOR_NAN
    event_handlers.on_state_toggle_off_on = [weak_ptr_this](const std::string& /* iface_name */) {
        const auto shared_ptr_this = weak_ptr_this.lock();
        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.
        NanStatus status = {NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
        for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
            if (!callback->eventDisabled(status).isOk()) {
                LOG(ERROR) << "Failed to invoke the callback";
            }
        }
    };
#endif
    iface_util_.lock()->registerIfaceEventHandlers(ifname_, event_handlers);
}

void WifiNanIface::setWeakPtr(std::weak_ptr<WifiNanIface> ptr) {
    weak_ptr_this_ = ptr;
}

void WifiNanIface::invalidate() {
    if (!isValid()) {
        return;
    }
    // send commands to HAL to actually disable and destroy interfaces
    legacy_hal_.lock()->nanDisableRequest(ifname_, 0xFFFF);
    legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFE, "aware_data0");
    legacy_hal_.lock()->nanDataInterfaceDelete(ifname_, 0xFFFD, "aware_data1");
    iface_util_.lock()->unregisterIfaceEventHandlers(ifname_);
    legacy_hal_.reset();
    event_cb_handler_.invalidate();
    is_valid_ = false;
    if (is_dedicated_iface_) {
        // If using a dedicated iface, set the iface down.
        iface_util_.lock()->setUpState(ifname_, false);
    }
}

bool WifiNanIface::isValid() {
    return is_valid_;
}

std::string WifiNanIface::getName() {
    return ifname_;
}

std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks() {
    LOG(ERROR) << "Using original getEventCallbacks";
    return event_cb_handler_.getCallbacks();
}

ndk::ScopedAStatus WifiNanIface::getName(std::string* _aidl_return) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::getNameInternal, _aidl_return);
}

ndk::ScopedAStatus WifiNanIface::registerEventCallback(
        const std::shared_ptr<IWifiNanIfaceEventCallback>& callback) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::registerEventCallbackInternal, callback);
}

ndk::ScopedAStatus WifiNanIface::getCapabilitiesRequest(char16_t in_cmdId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::getCapabilitiesRequestInternal, in_cmdId);
}

ndk::ScopedAStatus WifiNanIface::enableRequest(char16_t in_cmdId, const NanEnableRequest& in_msg1,
                                               const NanConfigRequestSupplemental& in_msg2) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::enableRequestInternal, in_cmdId, in_msg1, in_msg2);
}

ndk::ScopedAStatus WifiNanIface::configRequest(char16_t in_cmdId, const NanConfigRequest& in_msg1,
                                               const NanConfigRequestSupplemental& in_msg2) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::configRequestInternal, in_cmdId, in_msg1, in_msg2);
}

ndk::ScopedAStatus WifiNanIface::disableRequest(char16_t in_cmdId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::disableRequestInternal, in_cmdId);
}

ndk::ScopedAStatus WifiNanIface::startPublishRequest(char16_t in_cmdId,
                                                     const NanPublishRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::startPublishRequestInternal, in_cmdId, in_msg);
}

ndk::ScopedAStatus WifiNanIface::stopPublishRequest(char16_t in_cmdId, int8_t in_sessionId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::stopPublishRequestInternal, in_cmdId, in_sessionId);
}

ndk::ScopedAStatus WifiNanIface::startSubscribeRequest(char16_t in_cmdId,
                                                       const NanSubscribeRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::startSubscribeRequestInternal, in_cmdId, in_msg);
}

ndk::ScopedAStatus WifiNanIface::stopSubscribeRequest(char16_t in_cmdId, int8_t in_sessionId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::stopSubscribeRequestInternal, in_cmdId, in_sessionId);
}

ndk::ScopedAStatus WifiNanIface::transmitFollowupRequest(char16_t in_cmdId,
                                                         const NanTransmitFollowupRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::transmitFollowupRequestInternal, in_cmdId, in_msg);
}

ndk::ScopedAStatus WifiNanIface::createDataInterfaceRequest(char16_t in_cmdId,
                                                            const std::string& in_ifaceName) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::createDataInterfaceRequestInternal, in_cmdId,
                           in_ifaceName);
}

ndk::ScopedAStatus WifiNanIface::deleteDataInterfaceRequest(char16_t in_cmdId,
                                                            const std::string& in_ifaceName) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::deleteDataInterfaceRequestInternal, in_cmdId,
                           in_ifaceName);
}

ndk::ScopedAStatus WifiNanIface::initiateDataPathRequest(char16_t in_cmdId,
                                                         const NanInitiateDataPathRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::initiateDataPathRequestInternal, in_cmdId, in_msg);
}

ndk::ScopedAStatus WifiNanIface::respondToDataPathIndicationRequest(
        char16_t in_cmdId, const NanRespondToDataPathIndicationRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::respondToDataPathIndicationRequestInternal, in_cmdId,
                           in_msg);
}

ndk::ScopedAStatus WifiNanIface::terminateDataPathRequest(char16_t in_cmdId,
                                                          int32_t in_ndpInstanceId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::terminateDataPathRequestInternal, in_cmdId,
                           in_ndpInstanceId);
}

ndk::ScopedAStatus WifiNanIface::initiatePairingRequest(char16_t in_cmdId,
                                                        const NanPairingRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::initiatePairingRequestInternal, in_cmdId, in_msg);
}

ndk::ScopedAStatus WifiNanIface::respondToPairingIndicationRequest(
        char16_t in_cmdId, const NanRespondToPairingIndicationRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::respondToPairingIndicationRequestInternal, in_cmdId,
                           in_msg);
}

ndk::ScopedAStatus WifiNanIface::terminatePairingRequest(char16_t in_cmdId,
                                                         int32_t in_ndpInstanceId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::terminatePairingRequestInternal, in_cmdId,
                           in_ndpInstanceId);
}

ndk::ScopedAStatus WifiNanIface::initiateBootstrappingRequest(
        char16_t in_cmdId, const NanBootstrappingRequest& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::initiateBootstrappingRequestInternal, in_cmdId, in_msg);
}

ndk::ScopedAStatus WifiNanIface::respondToBootstrappingIndicationRequest(
        char16_t in_cmdId, const NanBootstrappingResponse& in_msg) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::respondToBootstrappingIndicationRequestInternal, in_cmdId,
                           in_msg);
}

ndk::ScopedAStatus WifiNanIface::suspendRequest(char16_t in_cmdId, int8_t in_sessionId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::suspendRequestInternal, in_cmdId, in_sessionId);
}

ndk::ScopedAStatus WifiNanIface::resumeRequest(char16_t in_cmdId, int8_t in_sessionId) {
    return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
                           &WifiNanIface::resumeRequestInternal, in_cmdId, in_sessionId);
}

std::pair<std::string, ndk::ScopedAStatus> WifiNanIface::getNameInternal() {
    return {ifname_, ndk::ScopedAStatus::ok()};
}

ndk::ScopedAStatus WifiNanIface::registerEventCallbackInternal(
        const std::shared_ptr<IWifiNanIfaceEventCallback>& callback) {
    if (!event_cb_handler_.addCallback(callback)) {
        return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
    }
    return ndk::ScopedAStatus::ok();
}

ndk::ScopedAStatus WifiNanIface::getCapabilitiesRequestInternal(char16_t cmd_id) {
    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanGetCapabilities(ifname_, cmd_id);
    return createWifiStatusFromLegacyError(legacy_status);
}

ndk::ScopedAStatus WifiNanIface::enableRequestInternal(char16_t cmd_id,
                                                       const NanEnableRequest& msg1,
                                                       const NanConfigRequestSupplemental& msg2) {
    legacy_hal::NanEnableRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanEnableRequestToLegacy(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);
}

ndk::ScopedAStatus WifiNanIface::configRequestInternal(char16_t cmd_id,
                                                       const NanConfigRequest& msg1,
                                                       const NanConfigRequestSupplemental& msg2) {
    legacy_hal::NanConfigRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanConfigRequestToLegacy(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);
}

ndk::ScopedAStatus WifiNanIface::disableRequestInternal(char16_t cmd_id) {
    legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->nanDisableRequest(ifname_, cmd_id);
    return createWifiStatusFromLegacyError(legacy_status);
}

ndk::ScopedAStatus WifiNanIface::startPublishRequestInternal(char16_t cmd_id,
                                                             const NanPublishRequest& msg) {
    legacy_hal::NanPublishRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanPublishRequestToLegacy(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);
}

ndk::ScopedAStatus WifiNanIface::stopPublishRequestInternal(char16_t cmd_id, int8_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);
}

ndk::ScopedAStatus WifiNanIface::startSubscribeRequestInternal(char16_t cmd_id,
                                                               const NanSubscribeRequest& msg) {
    legacy_hal::NanSubscribeRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanSubscribeRequestToLegacy(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);
}

ndk::ScopedAStatus WifiNanIface::stopSubscribeRequestInternal(char16_t cmd_id, int8_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);
}

ndk::ScopedAStatus WifiNanIface::transmitFollowupRequestInternal(
        char16_t cmd_id, const NanTransmitFollowupRequest& msg) {
    legacy_hal::NanTransmitFollowupRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanTransmitFollowupRequestToLegacy(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);
}

ndk::ScopedAStatus WifiNanIface::createDataInterfaceRequestInternal(char16_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);
}
ndk::ScopedAStatus WifiNanIface::deleteDataInterfaceRequestInternal(char16_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);
}
ndk::ScopedAStatus WifiNanIface::initiateDataPathRequestInternal(
        char16_t cmd_id, const NanInitiateDataPathRequest& msg) {
    legacy_hal::NanDataPathInitiatorRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanDataPathInitiatorRequestToLegacy(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);
}
ndk::ScopedAStatus WifiNanIface::respondToDataPathIndicationRequestInternal(
        char16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) {
    legacy_hal::NanDataPathIndicationResponse legacy_msg;
    if (!aidl_struct_util::convertAidlNanDataPathIndicationResponseToLegacy(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);
}
ndk::ScopedAStatus WifiNanIface::terminateDataPathRequestInternal(char16_t cmd_id,
                                                                  int32_t ndpInstanceId) {
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId);
    return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::initiatePairingRequestInternal(char16_t cmd_id,
                                                                const NanPairingRequest& msg) {
    legacy_hal::NanPairingRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanPairingInitiatorRequestToLegacy(msg, &legacy_msg)) {
        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
    }
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanPairingRequest(ifname_, cmd_id, legacy_msg);
    return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::respondToPairingIndicationRequestInternal(
        char16_t cmd_id, const NanRespondToPairingIndicationRequest& msg) {
    legacy_hal::NanPairingIndicationResponse legacy_msg;
    if (!aidl_struct_util::convertAidlNanPairingIndicationResponseToLegacy(msg, &legacy_msg)) {
        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
    }
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanPairingIndicationResponse(ifname_, cmd_id, legacy_msg);
    return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::terminatePairingRequestInternal(char16_t cmd_id,
                                                                 int32_t ndpInstanceId) {
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanPairingEnd(ifname_, cmd_id, ndpInstanceId);
    return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::initiateBootstrappingRequestInternal(
        char16_t cmd_id, const NanBootstrappingRequest& msg) {
    legacy_hal::NanBootstrappingRequest legacy_msg;
    if (!aidl_struct_util::convertAidlNanBootstrappingInitiatorRequestToLegacy(msg, &legacy_msg)) {
        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
    }
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanBootstrappingRequest(ifname_, cmd_id, legacy_msg);
    return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::respondToBootstrappingIndicationRequestInternal(
        char16_t cmd_id, const NanBootstrappingResponse& msg) {
    legacy_hal::NanBootstrappingIndicationResponse legacy_msg;
    if (!aidl_struct_util::convertAidlNanBootstrappingIndicationResponseToLegacy(msg,
                                                                                 &legacy_msg)) {
        return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
    }
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanBootstrappingIndicationResponse(ifname_, cmd_id, legacy_msg);
    return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::suspendRequestInternal(char16_t cmd_id, int8_t sessionId) {
    legacy_hal::NanSuspendRequest legacy_msg;
    legacy_msg.publish_subscribe_id = sessionId;
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanSuspendRequest(ifname_, cmd_id, legacy_msg);
    return createWifiStatusFromLegacyError(legacy_status);
}
ndk::ScopedAStatus WifiNanIface::resumeRequestInternal(char16_t cmd_id, int8_t sessionId) {
    legacy_hal::NanResumeRequest legacy_msg;
    legacy_msg.publish_subscribe_id = sessionId;
    legacy_hal::wifi_error legacy_status =
            legacy_hal_.lock()->nanResumeRequest(ifname_, cmd_id, legacy_msg);
    return createWifiStatusFromLegacyError(legacy_status);
}
}  // namespace wifi
}  // namespace hardware
}  // namespace android
}  // namespace aidl