diff --git a/wpa_supplicant/hidl/p2p_iface.cpp b/wpa_supplicant/hidl/p2p_iface.cpp
index e9ee986..e735684 100644
--- a/wpa_supplicant/hidl/p2p_iface.cpp
+++ b/wpa_supplicant/hidl/p2p_iface.cpp
@@ -8,7 +8,7 @@
  */
 
 #include "hidl_manager.h"
-#include "hidl_return_macros.h"
+#include "hidl_return_util.h"
 #include "p2p_iface.h"
 
 namespace android {
@@ -17,137 +17,152 @@
 namespace supplicant {
 namespace V1_0 {
 namespace implementation {
+using hidl_return_util::validateAndCall;
 
 P2pIface::P2pIface(struct wpa_global *wpa_global, const char ifname[])
-    : wpa_global_(wpa_global), ifname_(ifname)
+    : wpa_global_(wpa_global), ifname_(ifname), is_valid_(true)
 {
 }
 
+void P2pIface::invalidate() { is_valid_ = false; }
+bool P2pIface::isValid()
+{
+	return (is_valid_ && (retrieveIfacePtr() != nullptr));
+}
 Return<void> P2pIface::getName(getName_cb _hidl_cb)
 {
-	struct wpa_supplicant *wpa_s = retrieveP2pIfacePtr();
-	if (!wpa_s) {
-		HIDL_RETURN(
-		    SupplicantStatusCode::FAILURE_IFACE_INVALID, ifname_);
-	}
-
-	HIDL_RETURN(SupplicantStatusCode::SUCCESS, ifname_);
+	return validateAndCall(
+	    this, SupplicantStatusCode::FAILURE_IFACE_INVALID,
+	    &P2pIface::getNameInternal, _hidl_cb);
 }
 
 Return<void> P2pIface::getType(getType_cb _hidl_cb)
 {
-	struct wpa_supplicant *wpa_s = retrieveP2pIfacePtr();
-	if (!wpa_s) {
-		HIDL_RETURN(
-		    SupplicantStatusCode::FAILURE_IFACE_INVALID,
-		    IfaceType::STA);
-	}
-
-	HIDL_RETURN(SupplicantStatusCode::SUCCESS, IfaceType::STA);
+	return validateAndCall(
+	    this, SupplicantStatusCode::FAILURE_IFACE_INVALID,
+	    &P2pIface::getTypeInternal, _hidl_cb);
 }
 
 Return<void> P2pIface::addNetwork(addNetwork_cb _hidl_cb)
 {
-	android::sp<ISupplicantP2pNetwork> network;
-	struct wpa_supplicant *wpa_s = retrieveP2pIfacePtr();
-	if (!wpa_s) {
-		HIDL_RETURN(
-		    SupplicantStatusCode::FAILURE_IFACE_INVALID, network);
-	}
-
-	struct wpa_ssid *ssid = wpa_supplicant_add_network(wpa_s);
-	if (!ssid) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_UNKNOWN, network);
-	}
-
-	HidlManager *hidl_manager = HidlManager::getInstance();
-	if (!hidl_manager ||
-	    hidl_manager->getP2pNetworkHidlObjectByIfnameAndNetworkId(
-		wpa_s->ifname, ssid->id, &network)) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_UNKNOWN, network);
-	}
-
-	HIDL_RETURN(SupplicantStatusCode::SUCCESS, network);
+	return validateAndCall(
+	    this, SupplicantStatusCode::FAILURE_IFACE_INVALID,
+	    &P2pIface::addNetworkInternal, _hidl_cb);
 }
 
-Return<void> P2pIface::removeNetwork(uint32_t id, removeNetwork_cb _hidl_cb)
+Return<void> P2pIface::removeNetwork(
+    SupplicantNetworkId id, removeNetwork_cb _hidl_cb)
 {
-	struct wpa_supplicant *wpa_s = retrieveP2pIfacePtr();
-	if (!wpa_s) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_IFACE_INVALID);
-	}
-
-	int result = wpa_supplicant_remove_network(wpa_s, id);
-	if (result == -1) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN);
-	}
-
-	if (result != 0) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_UNKNOWN);
-	}
-
-	HIDL_RETURN(SupplicantStatusCode::SUCCESS);
+	return validateAndCall(
+	    this, SupplicantStatusCode::FAILURE_IFACE_INVALID,
+	    &P2pIface::removeNetworkInternal, _hidl_cb, id);
 }
 
-Return<void> P2pIface::getNetwork(uint32_t id, getNetwork_cb _hidl_cb)
+Return<void> P2pIface::getNetwork(
+    SupplicantNetworkId id, getNetwork_cb _hidl_cb)
 {
-	android::sp<ISupplicantP2pNetwork> network;
-	struct wpa_supplicant *wpa_s = retrieveP2pIfacePtr();
-	if (!wpa_s) {
-		HIDL_RETURN(
-		    SupplicantStatusCode::FAILURE_IFACE_INVALID, network);
-	}
-
-	struct wpa_ssid *ssid = wpa_config_get_network(wpa_s->conf, id);
-	if (!ssid) {
-		HIDL_RETURN(
-		    SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, network);
-	}
-
-	HidlManager *hidl_manager = HidlManager::getInstance();
-	if (!hidl_manager ||
-	    hidl_manager->getP2pNetworkHidlObjectByIfnameAndNetworkId(
-		wpa_s->ifname, ssid->id, &network)) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_UNKNOWN, network);
-	}
-
-	HIDL_RETURN(SupplicantStatusCode::SUCCESS, network);
+	return validateAndCall(
+	    this, SupplicantStatusCode::FAILURE_IFACE_INVALID,
+	    &P2pIface::getNetworkInternal, _hidl_cb, id);
 }
 
 Return<void> P2pIface::listNetworks(listNetworks_cb _hidl_cb)
 {
-	std::vector<uint32_t> network_ids;
-
-	struct wpa_supplicant *wpa_s = retrieveP2pIfacePtr();
-	if (!wpa_s) {
-		HIDL_RETURN(
-		    SupplicantStatusCode::FAILURE_IFACE_INVALID, network_ids);
-	}
-
-	for (struct wpa_ssid *wpa_ssid = wpa_s->conf->ssid; wpa_ssid;
-	     wpa_ssid = wpa_ssid->next) {
-		network_ids.emplace_back(wpa_ssid->id);
-	}
-
-	HIDL_RETURN(SupplicantStatusCode::SUCCESS, network_ids);
+	return validateAndCall(
+	    this, SupplicantStatusCode::FAILURE_IFACE_INVALID,
+	    &P2pIface::listNetworksInternal, _hidl_cb);
 }
 
 Return<void> P2pIface::registerCallback(
     const sp<ISupplicantP2pIfaceCallback> &callback,
     registerCallback_cb _hidl_cb)
 {
-	struct wpa_supplicant *wpa_s = retrieveP2pIfacePtr();
-	if (!wpa_s) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_IFACE_INVALID);
-	}
+	return validateAndCall(
+	    this, SupplicantStatusCode::FAILURE_IFACE_INVALID,
+	    &P2pIface::registerCallbackInternal, _hidl_cb, callback);
+}
 
+std::pair<SupplicantStatus, std::string> P2pIface::getNameInternal()
+{
+	return {{SupplicantStatusCode::SUCCESS, ""}, ifname_};
+}
+
+std::pair<SupplicantStatus, IfaceType> P2pIface::getTypeInternal()
+{
+	return {{SupplicantStatusCode::SUCCESS, ""}, IfaceType::P2P};
+}
+
+std::pair<SupplicantStatus, sp<ISupplicantP2pNetwork>>
+P2pIface::addNetworkInternal()
+{
+	android::sp<ISupplicantP2pNetwork> network;
+	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
+	struct wpa_ssid *ssid = wpa_supplicant_add_network(wpa_s);
+	if (!ssid) {
+		return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network};
+	}
+	HidlManager *hidl_manager = HidlManager::getInstance();
+	if (!hidl_manager ||
+	    hidl_manager->getP2pNetworkHidlObjectByIfnameAndNetworkId(
+		wpa_s->ifname, ssid->id, &network)) {
+		return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network};
+	}
+	return {{SupplicantStatusCode::SUCCESS, ""}, network};
+}
+
+SupplicantStatus P2pIface::removeNetworkInternal(SupplicantNetworkId id)
+{
+	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
+	int result = wpa_supplicant_remove_network(wpa_s, id);
+	if (result == -1) {
+		return {SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, ""};
+	}
+	if (result != 0) {
+		return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
+	}
+	return {SupplicantStatusCode::SUCCESS, ""};
+}
+
+std::pair<SupplicantStatus, sp<ISupplicantP2pNetwork>>
+P2pIface::getNetworkInternal(SupplicantNetworkId id)
+{
+	android::sp<ISupplicantP2pNetwork> network;
+	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
+	struct wpa_ssid *ssid = wpa_config_get_network(wpa_s->conf, id);
+	if (!ssid) {
+		return {{SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, ""},
+			network};
+	}
+	HidlManager *hidl_manager = HidlManager::getInstance();
+	if (!hidl_manager ||
+	    hidl_manager->getP2pNetworkHidlObjectByIfnameAndNetworkId(
+		wpa_s->ifname, ssid->id, &network)) {
+		return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network};
+	}
+	return {{SupplicantStatusCode::SUCCESS, ""}, network};
+}
+
+std::pair<SupplicantStatus, std::vector<SupplicantNetworkId>>
+P2pIface::listNetworksInternal()
+{
+	std::vector<SupplicantNetworkId> network_ids;
+	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
+	for (struct wpa_ssid *wpa_ssid = wpa_s->conf->ssid; wpa_ssid;
+	     wpa_ssid = wpa_ssid->next) {
+		network_ids.emplace_back(wpa_ssid->id);
+	}
+	return {{SupplicantStatusCode::SUCCESS, ""}, std::move(network_ids)};
+}
+
+SupplicantStatus P2pIface::registerCallbackInternal(
+    const sp<ISupplicantP2pIfaceCallback> &callback)
+{
 	HidlManager *hidl_manager = HidlManager::getInstance();
 	if (!hidl_manager ||
 	    hidl_manager->addP2pIfaceCallbackHidlObject(ifname_, callback)) {
-		HIDL_RETURN(SupplicantStatusCode::FAILURE_UNKNOWN);
+		return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
 	}
-
-	HIDL_RETURN(SupplicantStatusCode::SUCCESS);
+	return {SupplicantStatusCode::SUCCESS, ""};
 }
 
 /**
@@ -156,7 +171,7 @@
  * If the underlying iface is removed, then all RPC method calls on this object
  * will return failure.
  */
-wpa_supplicant *P2pIface::retrieveP2pIfacePtr()
+wpa_supplicant *P2pIface::retrieveIfacePtr()
 {
 	return wpa_supplicant_get_iface(
 	    (struct wpa_global *)wpa_global_, ifname_.c_str());
diff --git a/wpa_supplicant/hidl/p2p_iface.h b/wpa_supplicant/hidl/p2p_iface.h
index a003cf5..6459f29 100644
--- a/wpa_supplicant/hidl/p2p_iface.h
+++ b/wpa_supplicant/hidl/p2p_iface.h
@@ -42,27 +42,45 @@
 public:
 	P2pIface(struct wpa_global* wpa_global, const char ifname[]);
 	~P2pIface() override = default;
+	// Refer to |StaIface::invalidate()|.
+	void invalidate();
+	bool isValid();
 
 	// Hidl methods exposed.
 	Return<void> getName(getName_cb _hidl_cb) override;
 	Return<void> getType(getType_cb _hidl_cb) override;
 	Return<void> addNetwork(addNetwork_cb _hidl_cb) override;
 	Return<void> removeNetwork(
-	    uint32_t id, removeNetwork_cb _hidl_cb) override;
-	Return<void> getNetwork(uint32_t id, getNetwork_cb _hidl_cb) override;
+	    SupplicantNetworkId id, removeNetwork_cb _hidl_cb) override;
+	Return<void> getNetwork(
+	    SupplicantNetworkId id, getNetwork_cb _hidl_cb) override;
 	Return<void> listNetworks(listNetworks_cb _hidl_cb) override;
 	Return<void> registerCallback(
 	    const sp<ISupplicantP2pIfaceCallback>& callback,
 	    registerCallback_cb _hidl_cb) override;
 
 private:
-	struct wpa_supplicant* retrieveP2pIfacePtr();
+	// Corresponding worker functions for the HIDL methods.
+	std::pair<SupplicantStatus, std::string> getNameInternal();
+	std::pair<SupplicantStatus, IfaceType> getTypeInternal();
+	std::pair<SupplicantStatus, sp<ISupplicantP2pNetwork>>
+	addNetworkInternal();
+	SupplicantStatus removeNetworkInternal(SupplicantNetworkId id);
+	std::pair<SupplicantStatus, sp<ISupplicantP2pNetwork>>
+	getNetworkInternal(SupplicantNetworkId id);
+	std::pair<SupplicantStatus, std::vector<SupplicantNetworkId>>
+	listNetworksInternal();
+	SupplicantStatus registerCallbackInternal(
+	    const sp<ISupplicantP2pIfaceCallback>& callback);
+
+	struct wpa_supplicant* retrieveIfacePtr();
 
 	// Reference to the global wpa_struct. This is assumed to be valid for
 	// the lifetime of the process.
 	const struct wpa_global* wpa_global_;
 	// Name of the iface this hidl object controls
 	const std::string ifname_;
+	bool is_valid_;
 
 	DISALLOW_COPY_AND_ASSIGN(P2pIface);
 };