From f8fc237682dcc037490f8d48057fc0023be787a7 Mon Sep 17 00:00:00 2001 From: Sunil Ravi Date: Thu, 10 Nov 2022 18:37:41 +0000 Subject: [PATCH] Add frequency/Bandwidth to AIDL RttResults Bug: 222186547 Test: hardware/interfaces/wifi/aidl/default/tests/runtests.sh Test: Manual - Verified the results using wifirttscan app Change-Id: Ieaf022fa73767e62ae95e693a5cb062c7e002563 --- wifi/aidl/default/aidl_struct_util.cpp | 26 +++++ wifi/aidl/default/aidl_struct_util.h | 3 + .../tests/aidl_struct_util_unit_tests.cpp | 100 ++++++++++++++++++ wifi/aidl/default/wifi_legacy_hal.cpp | 48 +++++++-- wifi/aidl/default/wifi_legacy_hal.h | 7 +- wifi/aidl/default/wifi_rtt_controller.cpp | 22 +++- 6 files changed, 196 insertions(+), 10 deletions(-) diff --git a/wifi/aidl/default/aidl_struct_util.cpp b/wifi/aidl/default/aidl_struct_util.cpp index ec8b3968f2..0f1ed1025f 100644 --- a/wifi/aidl/default/aidl_struct_util.cpp +++ b/wifi/aidl/default/aidl_struct_util.cpp @@ -2270,6 +2270,8 @@ legacy_hal::wifi_rtt_bw convertAidlRttBwToLegacy(RttBw type) { return legacy_hal::WIFI_RTT_BW_160; case RttBw::BW_320MHZ: return legacy_hal::WIFI_RTT_BW_320; + case RttBw::BW_UNSPECIFIED: + return legacy_hal::WIFI_RTT_BW_UNSPECIFIED; }; CHECK(false); } @@ -2290,6 +2292,8 @@ RttBw convertLegacyRttBwToAidl(legacy_hal::wifi_rtt_bw type) { return RttBw::BW_160MHZ; case legacy_hal::WIFI_RTT_BW_320: return RttBw::BW_320MHZ; + case legacy_hal::WIFI_RTT_BW_UNSPECIFIED: + return RttBw::BW_UNSPECIFIED; }; CHECK(false) << "Unknown legacy type: " << type; } @@ -2619,6 +2623,28 @@ bool convertLegacyVectorOfRttResultToAidl( if (!convertLegacyRttResultToAidl(*legacy_result, &aidl_result)) { return false; } + aidl_result.channelFreqMHz = 0; + aidl_result.packetBw = RttBw::BW_UNSPECIFIED; + aidl_results->push_back(aidl_result); + } + return true; +} + +bool convertLegacyVectorOfRttResultV2ToAidl( + const std::vector& legacy_results, + std::vector* aidl_results) { + if (!aidl_results) { + return false; + } + *aidl_results = {}; + for (const auto legacy_result : legacy_results) { + RttResult aidl_result; + if (!convertLegacyRttResultToAidl(legacy_result->rtt_result, &aidl_result)) { + return false; + } + aidl_result.channelFreqMHz = + legacy_result->frequency != UNSPECIFIED ? legacy_result->frequency : 0; + aidl_result.packetBw = convertLegacyRttBwToAidl(legacy_result->packet_bw); aidl_results->push_back(aidl_result); } return true; diff --git a/wifi/aidl/default/aidl_struct_util.h b/wifi/aidl/default/aidl_struct_util.h index d8e1fd48aa..215b12b1e4 100644 --- a/wifi/aidl/default/aidl_struct_util.h +++ b/wifi/aidl/default/aidl_struct_util.h @@ -161,6 +161,9 @@ bool convertLegacyRttCapabilitiesToAidl( bool convertLegacyVectorOfRttResultToAidl( const std::vector& legacy_results, std::vector* aidl_results); +bool convertLegacyVectorOfRttResultV2ToAidl( + const std::vector& legacy_results, + std::vector* aidl_results); uint32_t convertAidlWifiBandToLegacyMacBand(WifiBand band); uint32_t convertAidlWifiIfaceModeToLegacy(uint32_t aidl_iface_mask); uint32_t convertAidlUsableChannelFilterToLegacy(uint32_t aidl_filter_mask); diff --git a/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp b/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp index 4a69c2426b..bd20c23608 100644 --- a/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp +++ b/wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp @@ -29,6 +29,12 @@ constexpr uint32_t kIfaceChannel1 = 3; constexpr uint32_t kIfaceChannel2 = 5; constexpr char kIfaceName1[] = "wlan0"; constexpr char kIfaceName2[] = "wlan1"; +constexpr uint8_t kMacAddress[] = {0x02, 0x12, 0x45, 0x56, 0xab, 0xcc}; +byte LCI[] = {0x27, 0x1A, 0x1, 0x00, 0x8, 0x01, 0x00, 0x08, 0x00, 0x10, 0x52, + 0x83, 0x4d, 0x12, 0xef, 0xd2, 0xb0, 0x8b, 0x9b, 0x4b, 0xf1, 0xcc, + 0x2c, 0x00, 0x00, 0x41, 0x06, 0x03, 0x06, 0x00, 0x80}; +byte LCR[] = {0x27, 0xE, 0x1, 0x00, 0xB, 0x01, 0x00, 0x0b, 0x00, 0x09, + 0x55, 0x53, 0x18, 0x05, 0x39, 0x34, 0x30, 0x34, 0x33}; } // namespace namespace aidl { @@ -479,6 +485,100 @@ TEST_F(AidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToAidl) { radio_configurations_array3); } +void verifyRttResult(wifi_rtt_result* legacy_rtt_result_ptr, RttResult* aidl_results_ptr) { + EXPECT_EQ((int)legacy_rtt_result_ptr->burst_num, aidl_results_ptr->burstNum); + EXPECT_EQ((int)legacy_rtt_result_ptr->measurement_number, aidl_results_ptr->measurementNumber); + EXPECT_EQ((int)legacy_rtt_result_ptr->success_number, aidl_results_ptr->successNumber); + EXPECT_EQ(legacy_rtt_result_ptr->number_per_burst_peer, aidl_results_ptr->numberPerBurstPeer); + EXPECT_EQ(legacy_rtt_result_ptr->retry_after_duration, aidl_results_ptr->retryAfterDuration); + EXPECT_EQ(legacy_rtt_result_ptr->rssi, aidl_results_ptr->rssi); + EXPECT_EQ(legacy_rtt_result_ptr->rssi_spread, aidl_results_ptr->rssiSpread); + EXPECT_EQ(legacy_rtt_result_ptr->rtt, aidl_results_ptr->rtt); + EXPECT_EQ(legacy_rtt_result_ptr->rtt_sd, aidl_results_ptr->rttSd); + EXPECT_EQ(legacy_rtt_result_ptr->rtt_spread, aidl_results_ptr->rttSpread); + EXPECT_EQ(legacy_rtt_result_ptr->distance_mm, aidl_results_ptr->distanceInMm); + EXPECT_EQ(legacy_rtt_result_ptr->distance_sd_mm, aidl_results_ptr->distanceSdInMm); + EXPECT_EQ(legacy_rtt_result_ptr->distance_spread_mm, aidl_results_ptr->distanceSpreadInMm); + EXPECT_EQ(legacy_rtt_result_ptr->ts, aidl_results_ptr->timeStampInUs); + EXPECT_EQ(legacy_rtt_result_ptr->burst_duration, aidl_results_ptr->burstDurationInMs); + EXPECT_EQ(legacy_rtt_result_ptr->negotiated_burst_num, aidl_results_ptr->negotiatedBurstNum); + EXPECT_EQ(legacy_rtt_result_ptr->LCI->id, aidl_results_ptr->lci.id); + for (int i = 0; i < legacy_rtt_result_ptr->LCI->len; i++) { + EXPECT_EQ(legacy_rtt_result_ptr->LCI->data[i], aidl_results_ptr->lci.data[i]); + } + EXPECT_EQ(legacy_rtt_result_ptr->LCR->id, aidl_results_ptr->lcr.id); + for (int i = 0; i < legacy_rtt_result_ptr->LCR->len; i++) { + EXPECT_EQ(legacy_rtt_result_ptr->LCR->data[i], aidl_results_ptr->lcr.data[i]); + } +} + +void fillLegacyRttResult(wifi_rtt_result* rtt_result_ptr) { + std::copy(std::begin(kMacAddress), std::end(kMacAddress), std::begin(rtt_result_ptr->addr)); + rtt_result_ptr->burst_num = rand(); + rtt_result_ptr->measurement_number = rand(); + rtt_result_ptr->success_number = rand(); + rtt_result_ptr->number_per_burst_peer = 0xF & rand(); + rtt_result_ptr->status = RTT_STATUS_SUCCESS; + rtt_result_ptr->retry_after_duration = 0xF & rand(); + rtt_result_ptr->type = RTT_TYPE_2_SIDED; + rtt_result_ptr->rssi = rand(); + rtt_result_ptr->rssi_spread = rand(); + rtt_result_ptr->rtt = rand(); + rtt_result_ptr->rtt_sd = rand(); + rtt_result_ptr->rtt_spread = rand(); + rtt_result_ptr->distance_mm = rand(); + rtt_result_ptr->distance_sd_mm = rand(); + rtt_result_ptr->distance_spread_mm = rand(); + rtt_result_ptr->burst_duration = rand(); + rtt_result_ptr->negotiated_burst_num = rand(); + rtt_result_ptr->LCI = (wifi_information_element*)LCI; + rtt_result_ptr->LCR = (wifi_information_element*)LCR; +} + +TEST_F(AidlStructUtilTest, convertLegacyVectorOfRttResultToAidl) { + std::vector rtt_results_vec; + wifi_rtt_result rttResults[2]; + + // fill legacy rtt results + for (int i = 0; i < 2; i++) { + fillLegacyRttResult(&rttResults[i]); + rtt_results_vec.push_back(&rttResults[i]); + } + + std::vector aidl_results; + aidl_struct_util::convertLegacyVectorOfRttResultToAidl(rtt_results_vec, &aidl_results); + + EXPECT_EQ(rtt_results_vec.size(), aidl_results.size()); + for (size_t i = 0; i < rtt_results_vec.size(); i++) { + verifyRttResult(&rttResults[i], &aidl_results[i]); + EXPECT_EQ(aidl_results[i].channelFreqMHz, 0); + EXPECT_EQ(aidl_results[i].packetBw, RttBw::BW_UNSPECIFIED); + } +} + +TEST_F(AidlStructUtilTest, convertLegacyVectorOfRttResultV2ToAidl) { + std::vector rtt_results_vec_v2; + wifi_rtt_result_v2 rttResults_v2[2]; + + // fill legacy rtt results v2 + for (int i = 0; i < 2; i++) { + fillLegacyRttResult(&rttResults_v2[i].rtt_result); + rttResults_v2[i].frequency = 2412 + i * 5; + rttResults_v2[i].packet_bw = WIFI_RTT_BW_80; + rtt_results_vec_v2.push_back(&rttResults_v2[i]); + } + + std::vector aidl_results; + aidl_struct_util::convertLegacyVectorOfRttResultV2ToAidl(rtt_results_vec_v2, &aidl_results); + + EXPECT_EQ(rtt_results_vec_v2.size(), aidl_results.size()); + for (size_t i = 0; i < rtt_results_vec_v2.size(); i++) { + verifyRttResult(&rttResults_v2[i].rtt_result, &aidl_results[i]); + EXPECT_EQ(aidl_results[i].channelFreqMHz, rttResults_v2[i].frequency); + EXPECT_EQ(aidl_results[i].packetBw, RttBw::BW_80MHZ); + } +} + } // namespace wifi } // namespace hardware } // namespace android diff --git a/wifi/aidl/default/wifi_legacy_hal.cpp b/wifi/aidl/default/wifi_legacy_hal.cpp index e4883d19f3..25f18b5484 100644 --- a/wifi/aidl/default/wifi_legacy_hal.cpp +++ b/wifi/aidl/default/wifi_legacy_hal.cpp @@ -171,11 +171,28 @@ void onAsyncSubsystemRestart(const char* error) { // Callback to be invoked for rtt results results. std::function on_rtt_results_internal_callback; +std::function + on_rtt_results_internal_callback_v2; + +void invalidateRttResultsCallbacks() { + on_rtt_results_internal_callback = nullptr; + on_rtt_results_internal_callback_v2 = nullptr; +}; + void onAsyncRttResults(wifi_request_id id, unsigned num_results, wifi_rtt_result* rtt_results[]) { const auto lock = aidl_sync_util::acquireGlobalLock(); if (on_rtt_results_internal_callback) { on_rtt_results_internal_callback(id, num_results, rtt_results); - on_rtt_results_internal_callback = nullptr; + invalidateRttResultsCallbacks(); + } +} + +void onAsyncRttResultsV2(wifi_request_id id, unsigned num_results, + wifi_rtt_result_v2* rtt_results_v2[]) { + const auto lock = aidl_sync_util::acquireGlobalLock(); + if (on_rtt_results_internal_callback_v2) { + on_rtt_results_internal_callback_v2(id, num_results, rtt_results_v2); + invalidateRttResultsCallbacks(); } } @@ -1090,8 +1107,9 @@ wifi_error WifiLegacyHal::registerSubsystemRestartCallbackHandler( wifi_error WifiLegacyHal::startRttRangeRequest( const std::string& iface_name, wifi_request_id id, const std::vector& rtt_configs, - const on_rtt_results_callback& on_results_user_callback) { - if (on_rtt_results_internal_callback) { + const on_rtt_results_callback& on_results_user_callback, + const on_rtt_results_callback_v2& on_results_user_callback_v2) { + if (on_rtt_results_internal_callback || on_rtt_results_internal_callback_v2) { return WIFI_ERROR_NOT_AVAILABLE; } @@ -1108,12 +1126,26 @@ wifi_error WifiLegacyHal::startRttRangeRequest( on_results_user_callback(id, rtt_results_vec); }; + on_rtt_results_internal_callback_v2 = [on_results_user_callback_v2]( + wifi_request_id id, unsigned num_results, + wifi_rtt_result_v2* rtt_results_v2[]) { + if (num_results > 0 && !rtt_results_v2) { + LOG(ERROR) << "Unexpected nullptr in RTT results"; + return; + } + std::vector rtt_results_vec_v2; + std::copy_if(rtt_results_v2, rtt_results_v2 + num_results, + back_inserter(rtt_results_vec_v2), + [](wifi_rtt_result_v2* rtt_result_v2) { return rtt_result_v2 != nullptr; }); + on_results_user_callback_v2(id, rtt_results_vec_v2); + }; + std::vector rtt_configs_internal(rtt_configs); wifi_error status = global_func_table_.wifi_rtt_range_request( id, getIfaceHandle(iface_name), rtt_configs.size(), rtt_configs_internal.data(), - {onAsyncRttResults}); + {onAsyncRttResults, onAsyncRttResultsV2}); if (status != WIFI_SUCCESS) { - on_rtt_results_internal_callback = nullptr; + invalidateRttResultsCallbacks(); } return status; } @@ -1121,7 +1153,7 @@ wifi_error WifiLegacyHal::startRttRangeRequest( wifi_error WifiLegacyHal::cancelRttRangeRequest( const std::string& iface_name, wifi_request_id id, const std::vector>& mac_addrs) { - if (!on_rtt_results_internal_callback) { + if (!on_rtt_results_internal_callback && !on_rtt_results_internal_callback_v2) { return WIFI_ERROR_NOT_AVAILABLE; } static_assert(sizeof(mac_addr) == sizeof(std::array), @@ -1135,7 +1167,7 @@ wifi_error WifiLegacyHal::cancelRttRangeRequest( // If the request Id is wrong, don't stop the ongoing range request. Any // other error should be treated as the end of rtt ranging. if (status != WIFI_ERROR_INVALID_REQUEST_ID) { - on_rtt_results_internal_callback = nullptr; + invalidateRttResultsCallbacks(); } return status; } @@ -1629,7 +1661,7 @@ void WifiLegacyHal::invalidate() { on_error_alert_internal_callback = nullptr; on_radio_mode_change_internal_callback = nullptr; on_subsystem_restart_internal_callback = nullptr; - on_rtt_results_internal_callback = nullptr; + invalidateRttResultsCallbacks(); on_nan_notify_response_user_callback = nullptr; on_nan_event_publish_terminated_user_callback = nullptr; on_nan_event_match_user_callback = nullptr; diff --git a/wifi/aidl/default/wifi_legacy_hal.h b/wifi/aidl/default/wifi_legacy_hal.h index 33ed359baa..cce43e653c 100644 --- a/wifi/aidl/default/wifi_legacy_hal.h +++ b/wifi/aidl/default/wifi_legacy_hal.h @@ -305,6 +305,7 @@ using ::WIFI_RTT_BW_320; using ::WIFI_RTT_BW_40; using ::WIFI_RTT_BW_5; using ::WIFI_RTT_BW_80; +using ::WIFI_RTT_BW_UNSPECIFIED; using ::wifi_rtt_capabilities; using ::wifi_rtt_config; using ::wifi_rtt_preamble; @@ -315,6 +316,7 @@ using ::WIFI_RTT_PREAMBLE_LEGACY; using ::WIFI_RTT_PREAMBLE_VHT; using ::wifi_rtt_responder; using ::wifi_rtt_result; +using ::wifi_rtt_result_v2; using ::wifi_rtt_status; using ::wifi_rtt_type; using ::wifi_rx_packet_fate; @@ -420,6 +422,8 @@ using on_rssi_threshold_breached_callback = // the pointer. using on_rtt_results_callback = std::function&)>; +using on_rtt_results_callback_v2 = + std::function&)>; // Callback for ring buffer data. using on_ring_buffer_data_callback = std::function& rtt_configs, - const on_rtt_results_callback& on_results_callback); + const on_rtt_results_callback& on_results_callback, + const on_rtt_results_callback_v2& on_results_callback_v2); wifi_error cancelRttRangeRequest(const std::string& iface_name, wifi_request_id id, const std::vector>& mac_addrs); std::pair getRttCapabilities(const std::string& iface_name); diff --git a/wifi/aidl/default/wifi_rtt_controller.cpp b/wifi/aidl/default/wifi_rtt_controller.cpp index 856c3cd054..a5f6768951 100644 --- a/wifi/aidl/default/wifi_rtt_controller.cpp +++ b/wifi/aidl/default/wifi_rtt_controller.cpp @@ -161,8 +161,28 @@ ndk::ScopedAStatus WifiRttController::rangeRequestInternal( } } }; + const auto& on_results_callback_v2 = + [weak_ptr_this](legacy_hal::wifi_request_id id, + const std::vector& results) { + const auto shared_ptr_this = weak_ptr_this.lock(); + if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { + LOG(ERROR) << "v2 Callback invoked on an invalid object"; + return; + } + std::vector aidl_results; + if (!aidl_struct_util::convertLegacyVectorOfRttResultV2ToAidl(results, + &aidl_results)) { + LOG(ERROR) << "Failed to convert rtt results v2 to AIDL structs"; + return; + } + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->onResults(id, aidl_results).isOk()) { + LOG(ERROR) << "Failed to invoke the v2 callback"; + } + } + }; legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequest( - ifname_, cmd_id, legacy_configs, on_results_callback); + ifname_, cmd_id, legacy_configs, on_results_callback, on_results_callback_v2); return createWifiStatusFromLegacyError(legacy_status); }