Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add Shim layer for new HAL about Aware pairing

Browse Source 
Bug: 249185683
Test: None

Change-Id: I87792a2b44afc6fb0d127b3b90f28e369e551242
This commit is contained in:
Nate Jiang
2022-12-02 17:30:27 -08:00
committed by Nate(Qiang) Jiang
parent 1590d09ac3
commit 38e8db5d92
7 changed files with 780 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

419
wifi/aidl/default/aidl_struct_util.cpp
View File

@@ -1261,6 +1261,165 @@ legacy_hal::NanDataPathChannelCfg convertAidlNanDataPathChannelCfgToLegacy(
CHECK(false);
}
legacy_hal::NanPairingRequestType convertAidlNanPairingRequestTypeToLegacy(
NanPairingRequestType type) {
switch (type) {
case NanPairingRequestType::NAN_PAIRING_SETUP:
return legacy_hal::NAN_PAIRING_SETUP;
case NanPairingRequestType::NAN_PAIRING_VERIFICATION:
return legacy_hal::NAN_PAIRING_VERIFICATION;
}
LOG(FATAL);
}
NanPairingRequestType convertLegacyNanPairingRequestTypeToAidl(
legacy_hal::NanPairingRequestType type) {
switch (type) {
case legacy_hal::NAN_PAIRING_SETUP:
return NanPairingRequestType::NAN_PAIRING_SETUP;
case legacy_hal::NAN_PAIRING_VERIFICATION:
return NanPairingRequestType::NAN_PAIRING_VERIFICATION;
}
LOG(FATAL);
}
legacy_hal::Akm convertAidlAkmTypeToLegacy(NanPairingAkm type) {
switch (type) {
case NanPairingAkm::SAE:
return legacy_hal::SAE;
case NanPairingAkm::PASN:
return legacy_hal::PASN;
}
LOG(FATAL);
}
NanPairingAkm convertLegacyAkmTypeToAidl(legacy_hal::Akm type) {
switch (type) {
case legacy_hal::SAE:
return NanPairingAkm::SAE;
case legacy_hal::PASN:
return NanPairingAkm::PASN;
}
LOG(FATAL);
}
uint16_t convertAidlBootstrappingMethodToLegacy(NanBootstrappingMethod type) {
switch (type) {
case NanBootstrappingMethod::BOOTSTRAPPING_OPPORTUNISTIC_MASK:
return NAN_PAIRING_BOOTSTRAPPING_OPPORTUNISTIC_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_QR_DISPLAY_MASK:
return NAN_PAIRING_BOOTSTRAPPING_QR_DISPLAY_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_NFC_TAG_MASK:
return NAN_PAIRING_BOOTSTRAPPING_NFC_TAG_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK:
return NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_QR_SCAN_MASK:
return NAN_PAIRING_BOOTSTRAPPING_QR_SCAN_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_NFC_READER_MASK:
return NAN_PAIRING_BOOTSTRAPPING_NFC_READER_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_SERVICE_MANAGED_MASK:
return NAN_PAIRING_BOOTSTRAPPING_SERVICE_MANAGED_MASK;
case NanBootstrappingMethod::BOOTSTRAPPING_HANDSHAKE_SHIP_MASK:
return NAN_PAIRING_BOOTSTRAPPING_HANDSHAKE_SHIP_MASK;
}
LOG(FATAL);
}
NanBootstrappingMethod convertLegacyBootstrappingMethodToAidl(uint16_t type) {
switch (type) {
case NAN_PAIRING_BOOTSTRAPPING_OPPORTUNISTIC_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_OPPORTUNISTIC_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK;
case NAN_PAIRING_BOOTSTRAPPING_QR_DISPLAY_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_QR_DISPLAY_MASK;
case NAN_PAIRING_BOOTSTRAPPING_NFC_TAG_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_NFC_TAG_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK;
case NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK;
case NAN_PAIRING_BOOTSTRAPPING_QR_SCAN_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_QR_SCAN_MASK;
case NAN_PAIRING_BOOTSTRAPPING_NFC_READER_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_NFC_READER_MASK;
case NAN_PAIRING_BOOTSTRAPPING_SERVICE_MANAGED_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_SERVICE_MANAGED_MASK;
case NAN_PAIRING_BOOTSTRAPPING_HANDSHAKE_SHIP_MASK:
return NanBootstrappingMethod::BOOTSTRAPPING_HANDSHAKE_SHIP_MASK;
}
LOG(FATAL);
return {};
}
bool covertAidlPairingConfigToLegacy(const NanPairingConfig& aidl_config,
legacy_hal::NanPairingConfig* legacy_config) {
if (!legacy_config) {
LOG(ERROR) << "covertAidlPairingConfigToLegacy: legacy_config is null";
return false;
}
legacy_config->enable_pairing_setup = aidl_config.enablePairingSetup ? 0x1 : 0x0;
legacy_config->enable_pairing_cache = aidl_config.enablePairingCache ? 0x1 : 0x0;
legacy_config->enable_pairing_verification = aidl_config.enablePairingVerification ? 0x1 : 0x0;
legacy_config->supported_bootstrapping_methods = aidl_config.supportedBootstrappingMethods;
return true;
}
bool convertLegacyPairingConfigToAidl(const legacy_hal::NanPairingConfig& legacy_config,
NanPairingConfig* aidl_config) {
if (!aidl_config) {
LOG(ERROR) << "convertLegacyPairingConfigToAidl: aidl_nira is null";
return false;
}
*aidl_config = {};
aidl_config->enablePairingSetup = legacy_config.enable_pairing_setup == 0x1;
aidl_config->enablePairingCache = legacy_config.enable_pairing_cache == 0x1;
aidl_config->enablePairingVerification = legacy_config.enable_pairing_verification == 0x1;
aidl_config->supportedBootstrappingMethods = legacy_config.supported_bootstrapping_methods;
return true;
}
bool convertLegacyNiraToAidl(const legacy_hal::NanIdentityResolutionAttribute& legacy_nira,
NanIdentityResolutionAttribute* aidl_nira) {
if (!aidl_nira) {
LOG(ERROR) << "convertLegacyNiraToAidl: aidl_nira is null";
return false;
}
*aidl_nira = {};
aidl_nira->nonce = std::array<uint8_t, 8>();
std::copy(legacy_nira.nonce, legacy_nira.nonce + 8, std::begin(aidl_nira->nonce));
aidl_nira->tag = std::array<uint8_t, 8>();
std::copy(legacy_nira.tag, legacy_nira.tag + 8, std::begin(aidl_nira->tag));
return true;
}
bool convertLegacyNpsaToAidl(const legacy_hal::NpkSecurityAssociation& legacy_npsa,
NpkSecurityAssociation* aidl_npsa) {
if (!aidl_npsa) {
LOG(ERROR) << "convertLegacyNiraToAidl: aidl_nira is null";
return false;
}
*aidl_npsa = {};
aidl_npsa->peerNanIdentityKey = std::array<uint8_t, 16>();
std::copy(legacy_npsa.peer_nan_identity_key, legacy_npsa.peer_nan_identity_key + 16,
std::begin(aidl_npsa->peerNanIdentityKey));
aidl_npsa->localNanIdentityKey = std::array<uint8_t, 16>();
std::copy(legacy_npsa.local_nan_identity_key, legacy_npsa.local_nan_identity_key + 16,
std::begin(aidl_npsa->localNanIdentityKey));
aidl_npsa->npk = std::array<uint8_t, 32>();
std::copy(legacy_npsa.npk.pmk, legacy_npsa.npk.pmk + 32, std::begin(aidl_npsa->npk));
aidl_npsa->akm = convertLegacyAkmTypeToAidl(legacy_npsa.akm);
return true;
}
NanStatusCode convertLegacyNanStatusTypeToAidl(legacy_hal::NanStatusType type) {
switch (type) {
case legacy_hal::NAN_STATUS_SUCCESS:
@@ -1289,6 +1448,10 @@ NanStatusCode convertLegacyNanStatusTypeToAidl(legacy_hal::NanStatusType type) {
return NanStatusCode::FOLLOWUP_TX_QUEUE_FULL;
case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
return NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
case legacy_hal::NAN_STATUS_INVALID_PAIRING_ID:
return NanStatusCode::INVALID_PAIRING_ID;
case legacy_hal::NAN_STATUS_INVALID_BOOTSTRAPPING_ID:
return NanStatusCode::INVALID_BOOTSTRAPPING_ID;
}
CHECK(false);
}
@@ -1679,6 +1842,12 @@ bool convertAidlNanPublishRequestToLegacy(const NanPublishRequest& aidl_request,
legacy_request->service_responder_policy = aidl_request.autoAcceptDataPathRequests
? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL
: legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
memcpy(legacy_request->nan_identity_key, aidl_request.identityKey.data(), NAN_IDENTITY_KEY_LEN);
if (!covertAidlPairingConfigToLegacy(aidl_request.pairingConfig,
&legacy_request->nan_pairing_config)) {
LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: invalid pairing config";
return false;
}
return true;
}
@@ -1819,7 +1988,12 @@ bool convertAidlNanSubscribeRequestToLegacy(const NanSubscribeRequest& aidl_requ
for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
memcpy(legacy_request->intf_addr[i], aidl_request.intfAddr[i].data.data(), 6);
}
memcpy(legacy_request->nan_identity_key, aidl_request.identityKey.data(), NAN_IDENTITY_KEY_LEN);
if (!covertAidlPairingConfigToLegacy(aidl_request.pairingConfig,
&legacy_request->nan_pairing_config)) {
LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: invalid pairing config";
return false;
}
return true;
}
@@ -2068,7 +2242,9 @@ bool convertLegacyNanCapabilitiesResponseToAidl(const legacy_hal::NanCapabilitie
aidl_response->supportedCipherSuites =
static_cast<NanCipherSuiteType>(legacy_response.cipher_suites_supported);
aidl_response->instantCommunicationModeSupportFlag = legacy_response.is_instant_mode_supported;
aidl_response->supports6g = legacy_response.is_6g_supported;
aidl_response->supportsHe = legacy_response.is_he_supported;
aidl_response->supportsPairing = legacy_response.is_pairing_supported;
return true;
}
@@ -2105,6 +2281,16 @@ bool convertLegacyNanMatchIndToAidl(const legacy_hal::NanMatchInd& legacy_ind,
aidl_ind->rangingIndicationType =
static_cast<NanRangingIndication>(legacy_ind.range_info.ranging_event_type);
aidl_ind->scid = std::vector<uint8_t>(legacy_ind.scid, legacy_ind.scid + legacy_ind.scid_len);
if (!convertLegacyNiraToAidl(legacy_ind.nira, &aidl_ind->peerNira)) {
LOG(ERROR) << "convertLegacyNanMatchIndToAidl: invalid NIRA";
return false;
}
if (!convertLegacyPairingConfigToAidl(legacy_ind.peer_pairing_config,
&aidl_ind->peerPairingConfig)) {
LOG(ERROR) << "convertLegacyNanMatchIndToAidl: invalid pairing config";
return false;
}
return true;
}
@@ -2861,6 +3047,235 @@ bool convertLegacyRadioCombinationsMatrixToAidl(
return true;
}
bool convertAidlNanPairingInitiatorRequestToLegacy(const NanPairingRequest& aidl_request,
legacy_hal::NanPairingRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->requestor_instance_id = aidl_request.peerId;
memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6);
legacy_request->nan_pairing_request_type =
convertAidlNanPairingRequestTypeToLegacy(aidl_request.requestType);
legacy_request->enable_pairing_cache = aidl_request.enablePairingCache;
memcpy(legacy_request->nan_identity_key, aidl_request.pairingIdentityKey.data(),
NAN_IDENTITY_KEY_LEN);
legacy_request->is_opportunistic =
aidl_request.securityConfig.securityType == NanPairingSecurityType::OPPORTUNISTIC ? 1
: 0;
legacy_request->akm = convertAidlAkmTypeToLegacy(aidl_request.securityConfig.akm);
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
return true;
}
bool convertAidlNanPairingIndicationResponseToLegacy(
const NanRespondToPairingIndicationRequest& aidl_request,
legacy_hal::NanPairingIndicationResponse* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->pairing_instance_id = aidl_request.pairingInstanceId;
legacy_request->nan_pairing_request_type =
convertAidlNanPairingRequestTypeToLegacy(aidl_request.requestType);
legacy_request->enable_pairing_cache = aidl_request.enablePairingCache;
memcpy(legacy_request->nan_identity_key, aidl_request.pairingIdentityKey.data(),
NAN_IDENTITY_KEY_LEN);
legacy_request->is_opportunistic =
aidl_request.securityConfig.securityType == NanPairingSecurityType::OPPORTUNISTIC ? 1
: 0;
legacy_request->akm = convertAidlAkmTypeToLegacy(aidl_request.securityConfig.akm);
legacy_request->rsp_code =
aidl_request.acceptRequest ? NAN_PAIRING_REQUEST_ACCEPT : NAN_PAIRING_REQUEST_REJECT;
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PMK) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK;
legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size();
if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"invalid pmk_len";
return false;
}
memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(),
legacy_request->key_info.body.pmk_info.pmk_len);
}
if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PASSPHRASE) {
legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
legacy_request->key_info.body.passphrase_info.passphrase_len =
aidl_request.securityConfig.passphrase.size();
if (legacy_request->key_info.body.passphrase_info.passphrase_len <
NAN_SECURITY_MIN_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"passphrase_len too small";
return false;
}
if (legacy_request->key_info.body.passphrase_info.passphrase_len >
NAN_SECURITY_MAX_PASSPHRASE_LEN) {
LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: "
"passphrase_len too large";
return false;
}
memcpy(legacy_request->key_info.body.passphrase_info.passphrase,
aidl_request.securityConfig.passphrase.data(),
legacy_request->key_info.body.passphrase_info.passphrase_len);
}
return true;
}
bool convertAidlNanBootstrappingInitiatorRequestToLegacy(
const NanBootstrappingRequest& aidl_request,
legacy_hal::NanBootstrappingRequest* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanBootstrappingInitiatorRequestToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->requestor_instance_id = aidl_request.peerId;
memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6);
legacy_request->request_bootstrapping_method =
convertAidlBootstrappingMethodToLegacy(aidl_request.requestBootstrappingMethod);
return true;
}
bool convertAidlNanBootstrappingIndicationResponseToLegacy(
const NanBootstrappingResponse& aidl_request,
legacy_hal::NanBootstrappingIndicationResponse* legacy_request) {
if (!legacy_request) {
LOG(ERROR) << "convertAidlNanBootstrappingIndicationResponseToLegacy: "
"legacy_request is null";
return false;
}
*legacy_request = {};
legacy_request->service_instance_id = aidl_request.bootstrappingInstanceId;
legacy_request->rsp_code = aidl_request.acceptRequest ? NAN_BOOTSTRAPPING_REQUEST_ACCEPT
: NAN_BOOTSTRAPPING_REQUEST_REJECT;
return true;
}
bool convertLegacyNanPairingRequestIndToAidl(const legacy_hal::NanPairingRequestInd& legacy_ind,
NanPairingRequestInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanPairingRequestIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
aidl_ind->peerId = legacy_ind.requestor_instance_id;
aidl_ind->peerDiscMacAddr = std::array<uint8_t, 6>();
std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6,
std::begin(aidl_ind->peerDiscMacAddr));
aidl_ind->pairingInstanceId = legacy_ind.pairing_instance_id;
aidl_ind->enablePairingCache = legacy_ind.enable_pairing_cache == 1;
aidl_ind->requestType =
convertLegacyNanPairingRequestTypeToAidl(legacy_ind.nan_pairing_request_type);
if (!convertLegacyNiraToAidl(legacy_ind.nira, &aidl_ind->peerNira)) {
return false;
}
return true;
}
bool convertLegacyNanPairingConfirmIndToAidl(const legacy_hal::NanPairingConfirmInd& legacy_ind,
NanPairingConfirmInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanPairingRequestIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->pairingInstanceId = legacy_ind.pairing_instance_id;
aidl_ind->enablePairingCache = legacy_ind.enable_pairing_cache == 1;
aidl_ind->requestType =
convertLegacyNanPairingRequestTypeToAidl(legacy_ind.nan_pairing_request_type);
aidl_ind->pairingSuccess = legacy_ind.rsp_code == NAN_PAIRING_REQUEST_ACCEPT;
aidl_ind->status.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code);
if (!convertLegacyNpsaToAidl(legacy_ind.npk_security_association, &aidl_ind->npksa)) {
return false;
}
return true;
}
bool convertLegacyNanBootstrappingRequestIndToAidl(
const legacy_hal::NanBootstrappingRequestInd& legacy_ind,
NanBootstrappingRequestInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanBootstrappingRequestIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
aidl_ind->peerId = legacy_ind.requestor_instance_id;
aidl_ind->peerDiscMacAddr = std::array<uint8_t, 6>();
std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6,
std::begin(aidl_ind->peerDiscMacAddr));
aidl_ind->bootstrappingInstanceId = legacy_ind.bootstrapping_instance_id;
aidl_ind->requestBootstrappingMethod =
convertLegacyBootstrappingMethodToAidl(legacy_ind.request_bootstrapping_method);
return true;
}
bool convertLegacyNanBootstrappingConfirmIndToAidl(
const legacy_hal::NanBootstrappingConfirmInd& legacy_ind,
NanBootstrappingConfirmInd* aidl_ind) {
if (!aidl_ind) {
LOG(ERROR) << "convertLegacyNanBootstrappingConfirmIndToAidl: aidl_ind is null";
return false;
}
*aidl_ind = {};
aidl_ind->bootstrappingInstanceId = legacy_ind.bootstrapping_instance_id;
aidl_ind->acceptRequest = legacy_ind.rsp_code == NAN_BOOTSTRAPPING_REQUEST_ACCEPT;
aidl_ind->reasonCode.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code);
return true;
}
bool convertLegacyWifiChipCapabilitiesToAidl(
const legacy_hal::wifi_chip_capabilities& legacy_chip_capabilities,
WifiChipCapabilities& aidl_chip_capabilities) {

21
wifi/aidl/default/aidl_struct_util.h
View File

@@ -176,6 +176,27 @@ bool convertLegacyWifiRateInfoToAidl(const legacy_hal::wifi_rate& legacy_rate,
bool convertLegacyWifiChipCapabilitiesToAidl(
const legacy_hal::wifi_chip_capabilities& legacy_chip_capabilities,
WifiChipCapabilities& aidl_chip_capabilities);
bool convertAidlNanPairingInitiatorRequestToLegacy(const NanPairingRequest& aidl_request,
legacy_hal::NanPairingRequest* legacy_request);
bool convertAidlNanPairingIndicationResponseToLegacy(
const NanRespondToPairingIndicationRequest& aidl_response,
legacy_hal::NanPairingIndicationResponse* legacy_response);
bool convertAidlNanBootstrappingInitiatorRequestToLegacy(
const NanBootstrappingRequest& aidl_request,
legacy_hal::NanBootstrappingRequest* legacy_request);
bool convertAidlNanBootstrappingIndicationResponseToLegacy(
const NanBootstrappingResponse& aidl_response,
legacy_hal::NanBootstrappingIndicationResponse* legacy_response);
bool convertLegacyNanPairingRequestIndToAidl(const legacy_hal::NanPairingRequestInd& legacy_ind,
NanPairingRequestInd* aidl_ind);
bool convertLegacyNanPairingConfirmIndToAidl(const legacy_hal::NanPairingConfirmInd& legacy_ind,
NanPairingConfirmInd* aidl_ind);
bool convertLegacyNanBootstrappingRequestIndToAidl(
const legacy_hal::NanBootstrappingRequestInd& legacy_ind,
NanBootstrappingRequestInd* aidl_ind);
bool convertLegacyNanBootstrappingConfirmIndToAidl(
const legacy_hal::NanBootstrappingConfirmInd& legacy_ind,
NanBootstrappingConfirmInd* aidl_ind);
} // namespace aidl_struct_util
} // namespace wifi
} // namespace hardware

107
wifi/aidl/default/wifi_legacy_hal.cpp
View File

@@ -334,6 +334,40 @@ void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
}
}
std::function<void(const NanPairingRequestInd&)> on_nan_event_pairing_request_user_callback;
void onAsyncNanEventPairingRequest(NanPairingRequestInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_pairing_request_user_callback && event) {
on_nan_event_pairing_request_user_callback(*event);
}
}
std::function<void(const NanPairingConfirmInd&)> on_nan_event_pairing_confirm_user_callback;
void onAsyncNanEventPairingConfirm(NanPairingConfirmInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_pairing_confirm_user_callback && event) {
on_nan_event_pairing_confirm_user_callback(*event);
}
}
std::function<void(const NanBootstrappingRequestInd&)>
on_nan_event_bootstrapping_request_user_callback;
void onAsyncNanEventBootstrappingRequest(NanBootstrappingRequestInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_bootstrapping_request_user_callback && event) {
on_nan_event_bootstrapping_request_user_callback(*event);
}
}
std::function<void(const NanBootstrappingConfirmInd&)>
on_nan_event_bootstrapping_confirm_user_callback;
void onAsyncNanEventBootstrappingConfirm(NanBootstrappingConfirmInd* event) {
const auto lock = aidl_sync_util::acquireGlobalLock();
if (on_nan_event_bootstrapping_confirm_user_callback && event) {
on_nan_event_bootstrapping_confirm_user_callback(*event);
}
}
// Callbacks for the various TWT operations.
std::function<void(const TwtSetupResponse&)> on_twt_event_setup_response_callback;
void onAsyncTwtEventSetupResponse(TwtSetupResponse* event) {
@@ -1298,6 +1332,12 @@ wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(const std::string& iface_n
on_nan_event_tca_user_callback = user_callbacks.on_event_tca;
on_nan_event_beacon_sdf_payload_user_callback = user_callbacks.on_event_beacon_sdf_payload;
on_nan_event_data_path_request_user_callback = user_callbacks.on_event_data_path_request;
on_nan_event_pairing_request_user_callback = user_callbacks.on_event_pairing_request;
on_nan_event_pairing_confirm_user_callback = user_callbacks.on_event_pairing_confirm;
on_nan_event_bootstrapping_request_user_callback =
user_callbacks.on_event_bootstrapping_request;
on_nan_event_bootstrapping_confirm_user_callback =
user_callbacks.on_event_bootstrapping_confirm;
on_nan_event_data_path_confirm_user_callback = user_callbacks.on_event_data_path_confirm;
on_nan_event_data_path_end_user_callback = user_callbacks.on_event_data_path_end;
on_nan_event_transmit_follow_up_user_callback = user_callbacks.on_event_transmit_follow_up;
@@ -1305,16 +1345,29 @@ wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(const std::string& iface_n
on_nan_event_range_report_user_callback = user_callbacks.on_event_range_report;
on_nan_event_schedule_update_user_callback = user_callbacks.on_event_schedule_update;
return global_func_table_.wifi_nan_register_handler(
getIfaceHandle(iface_name),
{onAsyncNanNotifyResponse, onAsyncNanEventPublishReplied,
onAsyncNanEventPublishTerminated, onAsyncNanEventMatch, onAsyncNanEventMatchExpired,
onAsyncNanEventSubscribeTerminated, onAsyncNanEventFollowup,
onAsyncNanEventDiscEngEvent, onAsyncNanEventDisabled, onAsyncNanEventTca,
onAsyncNanEventBeaconSdfPayload, onAsyncNanEventDataPathRequest,
onAsyncNanEventDataPathConfirm, onAsyncNanEventDataPathEnd,
onAsyncNanEventTransmitFollowUp, onAsyncNanEventRangeRequest,
onAsyncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
return global_func_table_.wifi_nan_register_handler(getIfaceHandle(iface_name),
{onAsyncNanNotifyResponse,
onAsyncNanEventPublishReplied,
onAsyncNanEventPublishTerminated,
onAsyncNanEventMatch,
onAsyncNanEventMatchExpired,
onAsyncNanEventSubscribeTerminated,
onAsyncNanEventFollowup,
onAsyncNanEventDiscEngEvent,
onAsyncNanEventDisabled,
onAsyncNanEventTca,
onAsyncNanEventBeaconSdfPayload,
onAsyncNanEventDataPathRequest,
onAsyncNanEventDataPathConfirm,
onAsyncNanEventDataPathEnd,
onAsyncNanEventTransmitFollowUp,
onAsyncNanEventRangeRequest,
onAsyncNanEventRangeReport,
onAsyncNanEventScheduleUpdate,
onAsyncNanEventPairingRequest,
onAsyncNanEventPairingConfirm,
onAsyncNanEventBootstrappingRequest,
onAsyncNanEventBootstrappingConfirm});
}
wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name, transaction_id id,
@@ -1429,6 +1482,36 @@ wifi_error WifiLegacyHal::nanDataIndicationResponse(const std::string& iface_nam
&msg_internal);
}
wifi_error WifiLegacyHal::nanPairingRequest(const std::string& iface_name, transaction_id id,
const NanPairingRequest& msg) {
NanPairingRequest msg_internal(msg);
return global_func_table_.wifi_nan_pairing_request(id, getIfaceHandle(iface_name),
&msg_internal);
}
wifi_error WifiLegacyHal::nanPairingIndicationResponse(const std::string& iface_name,
transaction_id id,
const NanPairingIndicationResponse& msg) {
NanPairingIndicationResponse msg_internal(msg);
return global_func_table_.wifi_nan_pairing_indication_response(id, getIfaceHandle(iface_name),
&msg_internal);
}
wifi_error WifiLegacyHal::nanBootstrappingRequest(const std::string& iface_name, transaction_id id,
const NanBootstrappingRequest& msg) {
NanBootstrappingRequest msg_internal(msg);
return global_func_table_.wifi_nan_bootstrapping_request(id, getIfaceHandle(iface_name),
&msg_internal);
}
wifi_error WifiLegacyHal::nanBootstrappingIndicationResponse(
const std::string& iface_name, transaction_id id,
const NanBootstrappingIndicationResponse& msg) {
NanBootstrappingIndicationResponse msg_internal(msg);
return global_func_table_.wifi_nan_bootstrapping_indication_response(
id, getIfaceHandle(iface_name), &msg_internal);
}
typedef struct {
u8 num_ndp_instances;
NanDataPathId ndp_instance_id;
@@ -1746,6 +1829,10 @@ void WifiLegacyHal::invalidate() {
on_nan_event_tca_user_callback = nullptr;
on_nan_event_beacon_sdf_payload_user_callback = nullptr;
on_nan_event_data_path_request_user_callback = nullptr;
on_nan_event_pairing_request_user_callback = nullptr;
on_nan_event_pairing_confirm_user_callback = nullptr;
on_nan_event_bootstrapping_request_user_callback = nullptr;
on_nan_event_bootstrapping_confirm_user_callback = nullptr;
on_nan_event_data_path_confirm_user_callback = nullptr;
on_nan_event_data_path_end_user_callback = nullptr;
on_nan_event_transmit_follow_up_user_callback = nullptr;

39
wifi/aidl/default/wifi_legacy_hal.h
View File

@@ -36,6 +36,7 @@ namespace wifi {
namespace legacy_hal {
// Import all the types defined inside the legacy HAL header files into this
// namespace.
using ::Akm;
using ::chre_nan_rtt_state;
using ::frame_info;
using ::frame_type;
@@ -44,6 +45,8 @@ using ::FRAME_TYPE_ETHERNET_II;
using ::FRAME_TYPE_UNKNOWN;
using ::fw_roaming_state_t;
using ::mac_addr;
using ::NAN_BOOTSTRAPPING_INITIATOR_RESPONSE;
using ::NAN_BOOTSTRAPPING_RESPONDER_RESPONSE;
using ::NAN_CHANNEL_24G_BAND;
using ::NAN_CHANNEL_5G_BAND_HIGH;
using ::NAN_CHANNEL_5G_BAND_LOW;
@@ -65,6 +68,10 @@ using ::NAN_GET_CAPABILITIES;
using ::NAN_MATCH_ALG_MATCH_CONTINUOUS;
using ::NAN_MATCH_ALG_MATCH_NEVER;
using ::NAN_MATCH_ALG_MATCH_ONCE;
using ::NAN_PAIRING_INITIATOR_RESPONSE;
using ::NAN_PAIRING_RESPONDER_RESPONSE;
using ::NAN_PAIRING_SETUP;
using ::NAN_PAIRING_VERIFICATION;
using ::NAN_PUBLISH_TYPE_SOLICITED;
using ::NAN_PUBLISH_TYPE_UNSOLICITED;
using ::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
@@ -97,7 +104,9 @@ using ::NAN_SSI_REQUIRED_IN_MATCH_IND;
using ::NAN_STATUS_ALREADY_ENABLED;
using ::NAN_STATUS_FOLLOWUP_QUEUE_FULL;
using ::NAN_STATUS_INTERNAL_FAILURE;
using ::NAN_STATUS_INVALID_BOOTSTRAPPING_ID;
using ::NAN_STATUS_INVALID_NDP_ID;
using ::NAN_STATUS_INVALID_PAIRING_ID;
using ::NAN_STATUS_INVALID_PARAM;
using ::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID;
using ::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID;
@@ -117,6 +126,12 @@ using ::NAN_TX_TYPE_BROADCAST;
using ::NAN_TX_TYPE_UNICAST;
using ::NAN_USE_SRF;
using ::NanBeaconSdfPayloadInd;
using ::NanBootstrappingConfirmInd;
using ::NanBootstrappingIndicationResponse;
using ::NanBootstrappingRequest;
using ::NanBootstrappingRequestInd;
using ::NanBootstrappingRequestResponse;
using ::NanBootstrappingResponseCode;
using ::NanCapabilities;
using ::NanChannelInfo;
using ::NanConfigRequest;
@@ -131,9 +146,18 @@ using ::NanDisabledInd;
using ::NanDiscEngEventInd;
using ::NanEnableRequest;
using ::NanFollowupInd;
using ::NanIdentityResolutionAttribute;
using ::NanMatchAlg;
using ::NanMatchExpiredInd;
using ::NanMatchInd;
using ::NanPairingConfig;
using ::NanPairingConfirmInd;
using ::NanPairingIndicationResponse;
using ::NanPairingRequest;
using ::NanPairingRequestInd;
using ::NanPairingRequestResponse;
using ::NanPairingRequestType;
using ::NanPairingResponseCode;
using ::NanPublishCancelRequest;
using ::NanPublishRequest;
using ::NanPublishTerminatedInd;
@@ -150,6 +174,8 @@ using ::NanSubscribeType;
using ::NanTransmitFollowupInd;
using ::NanTransmitFollowupRequest;
using ::NanTxType;
using ::NpkSecurityAssociation;
using ::PASN;
using ::ROAMING_DISABLE;
using ::ROAMING_ENABLE;
using ::RTT_PEER_AP;
@@ -189,6 +215,7 @@ using ::RX_PKT_FATE_FW_DROP_NOBUFS;
using ::RX_PKT_FATE_FW_DROP_OTHER;
using ::RX_PKT_FATE_FW_QUEUED;
using ::RX_PKT_FATE_SUCCESS;
using ::SAE;
using ::ssid_t;
using ::transaction_id;
using ::TX_PKT_FATE_ACKED;
@@ -412,6 +439,10 @@ struct NanCallbackHandlers {
std::function<void(const NanRangeRequestInd&)> on_event_range_request;
std::function<void(const NanRangeReportInd&)> on_event_range_report;
std::function<void(const NanDataPathScheduleUpdateInd&)> on_event_schedule_update;
std::function<void(const NanPairingRequestInd&)> on_event_pairing_request;
std::function<void(const NanPairingConfirmInd&)> on_event_pairing_confirm;
std::function<void(const NanBootstrappingRequestInd&)> on_event_bootstrapping_request;
std::function<void(const NanBootstrappingConfirmInd&)> on_event_bootstrapping_confirm;
};
// Full scan results contain IE info and are hence passed by reference, to
@@ -653,6 +684,14 @@ class WifiLegacyHal {
const NanDataPathInitiatorRequest& msg);
wifi_error nanDataIndicationResponse(const std::string& iface_name, transaction_id id,
const NanDataPathIndicationResponse& msg);
wifi_error nanPairingRequest(const std::string& iface_name, transaction_id id,
const NanPairingRequest& msg);
wifi_error nanPairingIndicationResponse(const std::string& iface_name, transaction_id id,
const NanPairingIndicationResponse& msg);
wifi_error nanBootstrappingRequest(const std::string& iface_name, transaction_id id,
const NanBootstrappingRequest& msg);
wifi_error nanBootstrappingIndicationResponse(const std::string& iface_name, transaction_id id,
const NanBootstrappingIndicationResponse& msg);
wifi_error nanDataEnd(const std::string& iface_name, transaction_id id, uint32_t ndpInstanceId);
// AP functions.
wifi_error setCountryCode(const std::string& iface_name, const std::array<uint8_t, 2> code);

4
wifi/aidl/default/wifi_legacy_hal_stubs.cpp
View File

@@ -126,6 +126,10 @@ bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn) {
populateStubFor(&hal_fn->wifi_nan_data_interface_delete);
populateStubFor(&hal_fn->wifi_nan_data_request_initiator);
populateStubFor(&hal_fn->wifi_nan_data_indication_response);
populateStubFor(&hal_fn->wifi_nan_pairing_request);
populateStubFor(&hal_fn->wifi_nan_pairing_indication_response);
populateStubFor(&hal_fn->wifi_nan_bootstrapping_request);
populateStubFor(&hal_fn->wifi_nan_bootstrapping_indication_response);
populateStubFor(&hal_fn->wifi_nan_data_end);
populateStubFor(&hal_fn->wifi_get_packet_filter_capabilities);
populateStubFor(&hal_fn->wifi_set_packet_filter);

186
wifi/aidl/default/wifi_nan_iface.cpp
View File

@@ -205,6 +205,46 @@ void WifiNanIface::registerCallbackHandlers() {
}
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_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_RESPONSE_BEACON_SDF_PAYLOAD:
/* fall through */
case legacy_hal::NAN_RESPONSE_TCA:
@@ -421,6 +461,85 @@ void WifiNanIface::registerCallbackHandlers() {
}
};
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";
@@ -611,6 +730,32 @@ ndk::ScopedAStatus WifiNanIface::terminateDataPathRequest(char16_t 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::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);
}
std::pair<std::string, ndk::ScopedAStatus> WifiNanIface::getNameInternal() {
return {ifname_, ndk::ScopedAStatus::ok()};
}
@@ -744,6 +889,47 @@ ndk::ScopedAStatus WifiNanIface::terminateDataPathRequestInternal(char16_t cmd_i
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::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);
}
} // namespace wifi
} // namespace hardware

16
wifi/aidl/default/wifi_nan_iface.h
View File

@@ -78,6 +78,14 @@ class WifiNanIface : public BnWifiNanIface {
char16_t in_cmdId, const NanRespondToDataPathIndicationRequest& in_msg) override;
ndk::ScopedAStatus terminateDataPathRequest(char16_t in_cmdId,
int32_t in_ndpInstanceId) override;
ndk::ScopedAStatus initiatePairingRequest(char16_t in_cmdId,
const NanPairingRequest& in_msg) override;
ndk::ScopedAStatus respondToPairingIndicationRequest(
char16_t in_cmdId, const NanRespondToPairingIndicationRequest& in_msg) override;
ndk::ScopedAStatus initiateBootstrappingRequest(char16_t in_cmdId,
const NanBootstrappingRequest& in_msg) override;
ndk::ScopedAStatus respondToBootstrappingIndicationRequest(
char16_t in_cmdId, const NanBootstrappingResponse& in_msg) override;
protected:
// Accessible to child class in the gTest suite.
@@ -111,6 +119,14 @@ class WifiNanIface : public BnWifiNanIface {
ndk::ScopedAStatus respondToDataPathIndicationRequestInternal(
char16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg);
ndk::ScopedAStatus terminateDataPathRequestInternal(char16_t cmd_id, int32_t ndpInstanceId);
ndk::ScopedAStatus initiatePairingRequestInternal(char16_t cmd_id,
const NanPairingRequest& msg);
ndk::ScopedAStatus respondToPairingIndicationRequestInternal(
char16_t cmd_id, const NanRespondToPairingIndicationRequest& msg);
ndk::ScopedAStatus initiateBootstrappingRequestInternal(char16_t cmd_id,
const NanBootstrappingRequest& msg);
ndk::ScopedAStatus respondToBootstrappingIndicationRequestInternal(
char16_t cmd_id, const NanBootstrappingResponse& msg);
// Overridden in the gTest suite.
virtual std::set<std::shared_ptr<IWifiNanIfaceEventCallback>> getEventCallbacks();