Merge changes If83c1cbe,I12ad2665 (3b815eee) · Commits · e / os / android_hardware_interfaces

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);
		}