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

Commit cdca0555 authored by Roshan Pius's avatar Roshan Pius Committed by Gerrit Code Review
Browse files

Merge changes If83c1cbe,I12ad2665 

* changes:
  wifi(implementation): Move out clearing on stop complete
  wifi(vts): Some IWifiChip/IWifiStaIface tests
parents 255cdb29 46b6454d

wifi/1.0/default/wifi_legacy_hal.cpp

+2 −1
Original line number Diff line number Diff line
@@ -59,6 +59,8 @@ void onAsyncStopComplete(wifi_handle handle) { 
  const auto lock = hidl_sync_util::acquireGlobalLock();

  if (on_stop_complete_internal_callback) {

    on_stop_complete_internal_callback(handle);

    // Invalidate this callback since we don't want this firing again.

    on_stop_complete_internal_callback = nullptr;

  }

}
@@ -1261,7 +1263,6 @@ WifiLegacyHal::getGscanCachedResults() { 
void WifiLegacyHal::invalidate() {

  global_handle_ = nullptr;

  wlan_interface_handle_ = nullptr;

  on_stop_complete_internal_callback = nullptr;

  on_driver_memory_dump_internal_callback = nullptr;

  on_firmware_memory_dump_internal_callback = nullptr;

  on_gscan_event_internal_callback = nullptr;

wifi/1.0/vts/functional/wifi_chip_hidl_test.cpp

+682 −2

File changed.

Preview size limit exceeded, changes collapsed.

wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp

+58 −57
Original line number Diff line number Diff line
@@ -35,6 +35,53 @@ using ::android::sp; 
using ::android::hardware::hidl_string;

using ::android::hardware::hidl_vec;



namespace {

bool findAnyModeSupportingIfaceType(

    IfaceType desired_type, const std::vector<IWifiChip::ChipMode>& modes,

    ChipModeId* mode_id) {

    for (const auto& mode : modes) {

        for (const auto& combination : mode.availableCombinations) {

            for (const auto& iface_limit : combination.limits) {

                const auto& iface_types = iface_limit.types;

                if (std::find(iface_types.begin(), iface_types.end(),

                              desired_type) != iface_types.end()) {

                    *mode_id = mode.id;

                    return true;

                }

            }

        }

    }

    return false;

}



bool configureChipToSupportIfaceTypeInternal(const sp<IWifiChip>& wifi_chip,

                                             IfaceType type,

                                             ChipModeId* configured_mode_id) {

    if (!configured_mode_id) {

        return false;

    }

    const auto& status_and_modes = HIDL_INVOKE(wifi_chip, getAvailableModes);

    if (status_and_modes.first.code != WifiStatusCode::SUCCESS) {

        return false;

    }

    if (!findAnyModeSupportingIfaceType(type, status_and_modes.second,

                                        configured_mode_id)) {

        return false;

    }

    if (HIDL_INVOKE(wifi_chip, configureChip, *configured_mode_id).code !=

        WifiStatusCode::SUCCESS) {

        return false;

    }

    return true;

}



bool configureChipToSupportIfaceTypeInternal(const sp<IWifiChip>& wifi_chip,

                                             IfaceType type) {

    ChipModeId mode_id;

    return configureChipToSupportIfaceTypeInternal(wifi_chip, type, &mode_id);

}

}  // namespace



void stopFramework() {

    ASSERT_EQ(std::system("stop"), 0);

    stopWifi();
@@ -53,79 +100,30 @@ sp<IWifiChip> getWifiChip() { 
    if (!wifi.get()) {

        return nullptr;

    }



    if (HIDL_INVOKE(wifi, start).code != WifiStatusCode::SUCCESS) {

        return nullptr;

    }



    const auto& status_and_chip_ids = HIDL_INVOKE(wifi, getChipIds);

    const auto& chip_ids = status_and_chip_ids.second;

    if (status_and_chip_ids.first.code != WifiStatusCode::SUCCESS ||

        chip_ids.size() != 1) {

        return nullptr;

    }



    const auto& status_and_chip = HIDL_INVOKE(wifi, getChip, chip_ids[0]);

    if (status_and_chip.first.code != WifiStatusCode::SUCCESS) {

        return nullptr;

    }



    return status_and_chip.second;

}



// Since we currently only support one iface of each type. Just iterate thru the

// modes of operation and find the mode ID to use for that iface type.

bool findModeToSupportIfaceType(IfaceType type,

                                const std::vector<IWifiChip::ChipMode>& modes,

                                ChipModeId* mode_id) {

    for (const auto& mode : modes) {

        std::vector<IWifiChip::ChipIfaceCombination> combinations =

            mode.availableCombinations;

        for (const auto& combination : combinations) {

            std::vector<IWifiChip::ChipIfaceCombinationLimit> iface_limits =

                combination.limits;

            for (const auto& iface_limit : iface_limits) {

                std::vector<IfaceType> iface_types = iface_limit.types;

                for (const auto& iface_type : iface_types) {

                    if (iface_type == type) {

                        *mode_id = mode.id;

                        return true;

                    }

                }

            }

        }

    }

    return false;

}



bool configureChipToSupportIfaceType(const sp<IWifiChip>& wifi_chip,

                                     IfaceType type) {

    const auto& status_and_modes = HIDL_INVOKE(wifi_chip, getAvailableModes);

    if (status_and_modes.first.code != WifiStatusCode::SUCCESS) {

        return false;

    }



    ChipModeId mode_id;

    if (!findModeToSupportIfaceType(type, status_and_modes.second, &mode_id)) {

        return false;

    }



    if (HIDL_INVOKE(wifi_chip, configureChip, mode_id).code !=

        WifiStatusCode::SUCCESS) {

        return false;

    }

    return true;

}



sp<IWifiApIface> getWifiApIface() {

    sp<IWifiChip> wifi_chip = getWifiChip();

    if (!wifi_chip.get()) {

        return nullptr;

    }

    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::AP)) {

    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::AP)) {

        return nullptr;

    }



    const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createApIface);

    if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {

        return nullptr;
@@ -138,10 +136,9 @@ sp<IWifiNanIface> getWifiNanIface() { 
    if (!wifi_chip.get()) {

        return nullptr;

    }

    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::NAN)) {

    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::NAN)) {

        return nullptr;

    }



    const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createNanIface);

    if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {

        return nullptr;
@@ -154,10 +151,9 @@ sp<IWifiP2pIface> getWifiP2pIface() { 
    if (!wifi_chip.get()) {

        return nullptr;

    }

    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::P2P)) {

    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::P2P)) {

        return nullptr;

    }



    const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createP2pIface);

    if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {

        return nullptr;
@@ -170,10 +166,9 @@ sp<IWifiStaIface> getWifiStaIface() { 
    if (!wifi_chip.get()) {

        return nullptr;

    }

    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::STA)) {

    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::STA)) {

        return nullptr;

    }



    const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createStaIface);

    if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {

        return nullptr;
@@ -190,7 +185,6 @@ sp<IWifiRttController> getWifiRttController() { 
    if (!wifi_sta_iface.get()) {

        return nullptr;

    }



    const auto& status_and_controller =

        HIDL_INVOKE(wifi_chip, createRttController, wifi_sta_iface);

    if (status_and_controller.first.code != WifiStatusCode::SUCCESS) {
@@ -199,6 +193,13 @@ sp<IWifiRttController> getWifiRttController() { 
    return status_and_controller.second;

}



bool configureChipToSupportIfaceType(const sp<IWifiChip>& wifi_chip,

                                     IfaceType type,

                                     ChipModeId* configured_mode_id) {

    return configureChipToSupportIfaceTypeInternal(wifi_chip, type,

                                                   configured_mode_id);

}



void stopWifi() {

    sp<IWifi> wifi = getWifi();

    ASSERT_NE(wifi, nullptr);

wifi/1.0/vts/functional/wifi_hidl_test_utils.h

+6 −0
Original line number Diff line number Diff line
@@ -41,5 +41,11 @@ android::sp<android::hardware::wifi::V1_0::IWifiP2pIface> getWifiP2pIface(); 
android::sp<android::hardware::wifi::V1_0::IWifiStaIface> getWifiStaIface();

android::sp<android::hardware::wifi::V1_0::IWifiRttController>

getWifiRttController();

// Configure the chip in a mode to support the creation of the provided

// iface type.

bool configureChipToSupportIfaceType(

    const android::sp<android::hardware::wifi::V1_0::IWifiChip>& wifi_chip,

    android::hardware::wifi::V1_0::IfaceType type,

    android::hardware::wifi::V1_0::ChipModeId* configured_mode_id);

// Used to trigger IWifi.stop() at the end of every test.

void stopWifi();

wifi/1.0/vts/functional/wifi_sta_iface_hidl_test.cpp

+18 −2
Original line number Diff line number Diff line
@@ -20,21 +20,28 @@ 


#include <VtsHalHidlTargetBaseTest.h>



#include "wifi_hidl_call_util.h"

#include "wifi_hidl_test_utils.h"



using ::android::hardware::wifi::V1_0::IWifiStaIface;

using ::android::sp;

using ::android::hardware::wifi::V1_0::IWifiStaIface;

using ::android::hardware::wifi::V1_0::WifiStatus;

using ::android::hardware::wifi::V1_0::WifiStatusCode;



/**

 * Fixture to use for all STA Iface HIDL interface tests.

 */

class WifiStaIfaceHidlTest : public ::testing::VtsHalHidlTargetBaseTest {

   public:

    virtual void SetUp() override {}

    virtual void SetUp() override {

        wifi_sta_iface_ = getWifiStaIface();

        ASSERT_NE(nullptr, wifi_sta_iface_.get());

    }



    virtual void TearDown() override { stopWifi(); }



   protected:

    sp<IWifiStaIface> wifi_sta_iface_;

};



/*
@@ -46,3 +53,12 @@ TEST(WifiStaIfaceHidlTestNoFixture, Create) { 
    EXPECT_NE(nullptr, getWifiStaIface().get());

    stopWifi();

}



/*

 * GetCapabilities:

 */

TEST_F(WifiStaIfaceHidlTest, GetCapabilities) {

    const auto& status_and_caps = HIDL_INVOKE(wifi_sta_iface_, getCapabilities);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);

    EXPECT_NE(0u, status_and_caps.second);

}