Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f8fc2376 authored by Sunil Ravi's avatar Sunil Ravi
Browse files

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
parent f6f61496

wifi/aidl/default/aidl_struct_util.cpp

+26 −0
Original line number Diff line number Diff line
@@ -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;

wifi/aidl/default/aidl_struct_util.h

+3 −0
Original line number Diff line number Diff line
@@ -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);

wifi/aidl/default/tests/aidl_struct_util_unit_tests.cpp

+100 −0
Original line number Diff line number Diff line
@@ -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

wifi/aidl/default/wifi_legacy_hal.cpp

+40 −8
Original line number Diff line number Diff line
@@ -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;

wifi/aidl/default/wifi_legacy_hal.h

+6 −1
Original line number Diff line number Diff line
@@ -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);