wifi: Add Iface related method implementations in WifiChip (11cbff5c) · Commits · e / os / android_hardware_interfaces

wifi/1.0/default/wifi_chip.cpp

+217 −9

Original line number	Diff line number	Diff line
		@@ -20,6 +20,32 @@

		#include "failure_reason_util.h"

		namespace {
		using android::sp;
		using android::hardware::hidl_vec;
		using android::hardware::hidl_string;

		hidl_vec<hidl_string> createHidlVecOfIfaceNames(const std::string& ifname) {
		std::vector<hidl_string> ifnames;
		if (!ifname.empty()) {
		hidl_string hidl_ifname;
		hidl_ifname = ifname.c_str();
		ifnames.emplace_back(hidl_ifname);
		}
		hidl_vec<hidl_string> hidl_ifnames;
		hidl_ifnames.setToExternal(ifnames.data(), ifnames.size());
		return hidl_ifnames;
		}

		template <typename Iface>
		void invalidateAndClear(sp<Iface>& iface) {
		if (iface.get()) {
		iface->invalidate();
		iface.clear();
		}
		}
		} // namepsace

		namespace android {
		namespace hardware {
		namespace wifi {
		@@ -28,11 +54,13 @@ namespace implementation {

		WifiChip::WifiChip(ChipId chip_id,
		const std::weak_ptr<WifiLegacyHal> legacy_hal)
		: chip_id_(chip_id), legacy_hal_(legacy_hal) {}
		: chip_id_(chip_id), legacy_hal_(legacy_hal), is_valid_(true) {}

		void WifiChip::invalidate() {
		invalidateAndRemoveAllIfaces();
		legacy_hal_.reset();
		callbacks_.clear();
		is_valid_ = false;
		}

		Return<ChipId> WifiChip::getId() {
		@@ -41,15 +69,15 @@ Return<ChipId> WifiChip::getId() {

		Return<void> WifiChip::registerEventCallback(
		const sp<IWifiChipEventCallback>& callback) {
		if (!legacy_hal_.lock())
		if (!is_valid_)
		return Void();
		// TODO(b/31632518): remove the callback when the client is destroyed
		callbacks_.insert(callback);
		callbacks_.emplace_back(callback);
		return Void();
		}

		Return<void> WifiChip::getAvailableModes(getAvailableModes_cb cb) {
		if (!legacy_hal_.lock()) {
		if (!is_valid_) {
		cb(hidl_vec<ChipMode>());
		return Void();
		} else {
		@@ -59,21 +87,23 @@ Return<void> WifiChip::getAvailableModes(getAvailableModes_cb cb) {
		}

		Return<void> WifiChip::configureChip(uint32_t /mode_id/) {
		if (!legacy_hal_.lock())
		if (!is_valid_)
		return Void();

		invalidateAndRemoveAllIfaces();
		// TODO add implementation
		return Void();
		}

		Return<uint32_t> WifiChip::getMode() {
		if (!legacy_hal_.lock())
		if (!is_valid_)
		return 0;
		// TODO add implementation
		return 0;
		}

		Return<void> WifiChip::requestChipDebugInfo() {
		if (!legacy_hal_.lock())
		if (!is_valid_)
		return Void();

		IWifiChipEventCallback::ChipDebugInfo result;
		@@ -102,7 +132,7 @@ Return<void> WifiChip::requestChipDebugInfo() {
		}

		Return<void> WifiChip::requestDriverDebugDump() {
		if (!legacy_hal_.lock())
		if (!is_valid_)
		return Void();

		std::pair<wifi_error, std::vector<char>> ret =
		@@ -124,7 +154,7 @@ Return<void> WifiChip::requestDriverDebugDump() {
		}

		Return<void> WifiChip::requestFirmwareDebugDump() {
		if (!legacy_hal_.lock())
		if (!is_valid_)
		return Void();

		std::pair<wifi_error, std::vector<char>> ret =
		@@ -145,6 +175,184 @@ Return<void> WifiChip::requestFirmwareDebugDump() {
		return Void();
		}

		Return<void> WifiChip::createApIface(createApIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		// TODO(b/31997422): Disallow this based on the chip combination.
		std::string ifname = legacy_hal_.lock()->getApIfaceName();
		ap_iface_ = new WifiApIface(ifname, legacy_hal_);
		cb(ap_iface_);
		return Void();
		}

		Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb cb) {
		if (!is_valid_) {
		cb(hidl_vec<hidl_string>());
		return Void();
		}

		std::string ifname;
		if (ap_iface_.get()) {
		ifname = legacy_hal_.lock()->getApIfaceName().c_str();
		}
		cb(createHidlVecOfIfaceNames(ifname));
		return Void();
		}

		Return<void> WifiChip::getApIface(const hidl_string& ifname, getApIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		if (ap_iface_.get() &&
		(ifname.c_str() == legacy_hal_.lock()->getApIfaceName())) {
		cb(ap_iface_);
		} else {
		cb(nullptr);
		}
		return Void();
		}

		Return<void> WifiChip::createNanIface(createNanIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		// TODO(b/31997422): Disallow this based on the chip combination.
		std::string ifname = legacy_hal_.lock()->getNanIfaceName();
		nan_iface_ = new WifiNanIface(ifname, legacy_hal_);
		cb(nan_iface_);
		return Void();
		}

		Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb cb) {
		if (!is_valid_) {
		cb(hidl_vec<hidl_string>());
		return Void();
		}

		std::string ifname;
		if (nan_iface_.get()) {
		ifname = legacy_hal_.lock()->getNanIfaceName().c_str();
		}
		cb(createHidlVecOfIfaceNames(ifname));
		return Void();
		}

		Return<void> WifiChip::getNanIface(const hidl_string& ifname,
		getNanIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		if (nan_iface_.get() &&
		(ifname.c_str() == legacy_hal_.lock()->getNanIfaceName())) {
		cb(nan_iface_);
		} else {
		cb(nullptr);
		}
		return Void();
		}

		Return<void> WifiChip::createP2pIface(createP2pIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		// TODO(b/31997422): Disallow this based on the chip combination.
		std::string ifname = legacy_hal_.lock()->getP2pIfaceName();
		p2p_iface_ = new WifiP2pIface(ifname, legacy_hal_);
		cb(p2p_iface_);
		return Void();
		}

		Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb cb) {
		if (!is_valid_) {
		cb(hidl_vec<hidl_string>());
		return Void();
		}

		std::string ifname;
		if (p2p_iface_.get()) {
		ifname = legacy_hal_.lock()->getP2pIfaceName().c_str();
		}
		cb(createHidlVecOfIfaceNames(ifname));
		return Void();
		}

		Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
		getP2pIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		if (p2p_iface_.get() &&
		(ifname.c_str() == legacy_hal_.lock()->getP2pIfaceName())) {
		cb(p2p_iface_);
		} else {
		cb(nullptr);
		}
		return Void();
		}

		Return<void> WifiChip::createStaIface(createStaIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		// TODO(b/31997422): Disallow this based on the chip combination.
		std::string ifname = legacy_hal_.lock()->getStaIfaceName();
		sta_iface_ = new WifiStaIface(ifname, legacy_hal_);
		cb(sta_iface_);
		return Void();
		}

		Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb cb) {
		if (!is_valid_) {
		cb(hidl_vec<hidl_string>());
		return Void();
		}

		std::string ifname;
		if (sta_iface_.get()) {
		ifname = legacy_hal_.lock()->getStaIfaceName().c_str();
		}
		cb(createHidlVecOfIfaceNames(ifname));
		return Void();
		}

		Return<void> WifiChip::getStaIface(const hidl_string& ifname,
		getStaIface_cb cb) {
		if (!is_valid_) {
		cb(nullptr);
		return Void();
		}

		if (sta_iface_.get() &&
		(ifname.c_str() == legacy_hal_.lock()->getStaIfaceName())) {
		cb(sta_iface_);
		} else {
		cb(nullptr);
		}
		return Void();
		}

		void WifiChip::invalidateAndRemoveAllIfaces() {
		invalidateAndClear(ap_iface_);
		invalidateAndClear(nan_iface_);
		invalidateAndClear(p2p_iface_);
		invalidateAndClear(sta_iface_);
		}

		} // namespace implementation
		} // namespace V1_0
		} // namespace wifi

wifi/1.0/default/wifi_chip.h

+28 −2

Original line number	Diff line number	Diff line
		@@ -17,12 +17,16 @@
		#ifndef WIFI_CHIP_H_
		#define WIFI_CHIP_H_

		#include <set>
		#include <map>

		#include <android-base/macros.h>
		#include <android/hardware/wifi/1.0/IWifiChip.h>

		#include "wifi_ap_iface.h"
		#include "wifi_legacy_hal.h"
		#include "wifi_nan_iface.h"
		#include "wifi_p2p_iface.h"
		#include "wifi_sta_iface.h"

		namespace android {
		namespace hardware {
		@@ -63,11 +67,33 @@ class WifiChip : public IWifiChip {
		Return<void> requestChipDebugInfo() override;
		Return<void> requestDriverDebugDump() override;
		Return<void> requestFirmwareDebugDump() override;
		Return<void> createApIface(createApIface_cb cb) override;
		Return<void> getApIfaceNames(getApIfaceNames_cb cb) override;
		Return<void> getApIface(const hidl_string& ifname, getApIface_cb cb) override;
		Return<void> createNanIface(createNanIface_cb cb) override;
		Return<void> getNanIfaceNames(getNanIfaceNames_cb cb) override;
		Return<void> getNanIface(const hidl_string& ifname,
		getNanIface_cb cb) override;
		Return<void> createP2pIface(createP2pIface_cb cb) override;
		Return<void> getP2pIfaceNames(getP2pIfaceNames_cb cb) override;
		Return<void> getP2pIface(const hidl_string& ifname,
		getP2pIface_cb cb) override;
		Return<void> createStaIface(createStaIface_cb cb) override;
		Return<void> getStaIfaceNames(getStaIfaceNames_cb cb) override;
		Return<void> getStaIface(const hidl_string& ifname,
		getStaIface_cb cb) override;

		private:
		void invalidateAndRemoveAllIfaces();

		ChipId chip_id_;
		std::weak_ptr<WifiLegacyHal> legacy_hal_;
		std::set<sp<IWifiChipEventCallback>> callbacks_;
		std::vector<sp<IWifiChipEventCallback>> callbacks_;
		sp<WifiApIface> ap_iface_;
		sp<WifiNanIface> nan_iface_;
		sp<WifiP2pIface> p2p_iface_;
		sp<WifiStaIface> sta_iface_;
		bool is_valid_;

		DISALLOW_COPY_AND_ASSIGN(WifiChip);
		};