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

Add frequency/Bandwidth to AIDL RttResults

Browse Source 
Bug: 222186547
Test: hardware/interfaces/wifi/aidl/default/tests/runtests.sh
Test: Manual - Verified the results using wifirttscan app
Change-Id: Ieaf022fa73767e62ae95e693a5cb062c7e002563
This commit is contained in:
Sunil Ravi
2022-11-10 18:37:41 +00:00
parent f6f6149640
commit f8fc237682
6 changed files with 196 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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<const legacy_hal::wifi_rtt_result_v2*>& legacy_results,
std::vector<RttResult>* 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;

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

@@ -161,6 +161,9 @@ bool convertLegacyRttCapabilitiesToAidl(
bool convertLegacyVectorOfRttResultToAidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
std::vector<RttResult>* aidl_results);
bool convertLegacyVectorOfRttResultV2ToAidl(
const std::vector<const legacy_hal::wifi_rtt_result_v2*>& legacy_results,
std::vector<RttResult>* aidl_results);
uint32_t convertAidlWifiBandToLegacyMacBand(WifiBand band);
uint32_t convertAidlWifiIfaceModeToLegacy(uint32_t aidl_iface_mask);
uint32_t convertAidlUsableChannelFilterToLegacy(uint32_t aidl_filter_mask);

100
wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp
View File

@@ -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<const wifi_rtt_result*> 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<RttResult> 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<const wifi_rtt_result_v2*> 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<RttResult> 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

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

@@ -171,11 +171,28 @@ void onAsyncSubsystemRestart(const char* error) {
// Callback to be invoked for rtt results results.
std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result* rtt_results[])>
on_rtt_results_internal_callback;
std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result_v2* rtt_results_v2[])>
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<wifi_rtt_config>& 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<const wifi_rtt_result_v2*> 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<wifi_rtt_config> 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<std::array<uint8_t, ETH_ALEN>>& 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<uint8_t, ETH_ALEN>),
@@ -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;

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

@@ -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<void(wifi_request_id, const std::vector<const wifi_rtt_result*>&)>;
using on_rtt_results_callback_v2 =
std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v2*>&)>;
// Callback for ring buffer data.
using on_ring_buffer_data_callback = std::function<void(
@@ -590,7 +594,8 @@ class WifiLegacyHal {
// RTT functions.
wifi_error startRttRangeRequest(const std::string& iface_name, wifi_request_id id,
const std::vector<wifi_rtt_config>& 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<std::array<uint8_t, ETH_ALEN>>& mac_addrs);
std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities(const std::string& iface_name);

22
wifi/aidl/default/wifi_rtt_controller.cpp
View File

@@ -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<const legacy_hal::wifi_rtt_result_v2*>& 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<RttResult> 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);
}