network: add WifiDeviceMode, update NM wireless logic

- Add WifiDeviceMode and WifiDevice.mode
- Add module.md
- Reimplement NMWirelessNetwork
- Fix mode checking for NMWirelessDevice
onConnectionLoaded/onAccessPointLoaded
- Move security type to bindings in NMAccessPoint and
NMConnectionSettings

Author: cpwrs

src/network/device.cpp

@@ -42,8 +42,7 @@ QString NMDeviceState::toString(NMDeviceState::Enum state) {
 	case NeedAuth: return QStringLiteral("Waiting for authentication");
 	case IPConfig: return QStringLiteral("Requesting IPv4 and/or IPv6 addresses from the network");
 	case IPCheck:
-		return QStringLiteral("Checking whether further action is required for the requested connection"
-		);
+		return QStringLiteral("Checking if further action is required for the requested connection");
 	case Secondaries:
 		return QStringLiteral("Waiting for a required secondary connection to activate");
 	case Activated: return QStringLiteral("Connected");

src/network/module.md

@@ -0,0 +1,13 @@
+name = "Quickshell.Network"
+description = "Network API"
+headers = [
+	"network.hpp",
+	"device.hpp",
+	"wifi.hpp",
+]
+-----
+This modules exposes Network management APIs provided by a supported network backend.
+For now, the only backend available is the NetworkManager DBus interface.
+Both DBus and NetworkManager must be running to use it.
+
+See the @@Quickshell.Network.Network singleton.

src/network/network.cpp

@@ -17,14 +17,15 @@ QS_LOGGING_CATEGORY(logNetwork, "quickshell.network", QtWarningMsg);
 } // namespace
 
 Network::Network(QObject* parent): QObject(parent) {
-	// NetworkManager
+	// Try to create the NetworkManager backend and bind to it.
 	auto* nm = new NetworkManager(this);
 	if (nm->isAvailable()) {
 		QObject::connect(nm, &NetworkManager::deviceAdded, this, &Network::onDeviceAdded);
 		QObject::connect(nm, &NetworkManager::deviceRemoved, this, &Network::onDeviceRemoved);
+		QObject::connect(this, &Network::requestSetWifiEnabled, nm, &NetworkManager::setWifiEnabled);
 		this->bindableWifiEnabled().setBinding([nm]() { return nm->wifiEnabled(); });
 		this->bindableWifiHardwareEnabled().setBinding([nm]() { return nm->wifiHardwareEnabled(); });
-		QObject::connect(this, &Network::requestSetWifiEnabled, nm, &NetworkManager::setWifiEnabled);
+
 		this->mBackend = nm;
 		this->mBackendType = NetworkBackendType::NetworkManager;
 		return;
@@ -41,7 +42,7 @@ void Network::onDeviceRemoved(NetworkDevice* dev) { this->mDevices.removeObject(
 void Network::setWifiEnabled(bool enabled) {
 	if (this->bWifiEnabled == enabled) {
 		const QString state = enabled ? "enabled" : "disabled";
-		qCCritical(logNetwork) << "Wifi is already software" << state;
+		qCCritical(logNetwork) << "Wifi is already globally software" << state;
 	} else {
 		emit this->requestSetWifiEnabled(enabled);
 	}

src/network/network.hpp

@@ -48,9 +48,9 @@ class Network: public QObject {
 	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::Network::Device>*);
 	/// The backend being used to power the Network service.
 	Q_PROPERTY(qs::network::NetworkBackendType::Enum backend READ backend CONSTANT);
-	/// Master switch for the status of the rfkill software block of all wireless devices.
+	/// Switch for the rfkill software block of all wireless devices.
 	Q_PROPERTY(bool wifiEnabled READ wifiEnabled WRITE setWifiEnabled NOTIFY wifiEnabledChanged);
-	/// Master switch for the status of the rfkill hardware block of all wireless devices.
+	/// Switch for the rfkill hardware block of all wireless devices.
 	Q_PROPERTY(bool wifiHardwareEnabled READ wifiHardwareEnabled NOTIFY wifiHardwareEnabledChanged BINDABLE bindableWifiHardwareEnabled);
 	// clang-format on
 
@@ -90,9 +90,9 @@ class BaseNetwork: public QObject {
 	QML_ELEMENT;
 	QML_UNCREATABLE("BaseNetwork can only be aqcuired through network devices");
 
-	/// The name of the network
+	/// The name of the network.
 	Q_PROPERTY(QString name READ name CONSTANT);
-	/// True if the network is connected to.
+	/// True if the network is connected.
 	Q_PROPERTY(bool connected READ connected NOTIFY connectedChanged BINDABLE bindableConnected);
 
 public:

src/network/nm/accesspoint.cpp

@@ -29,15 +29,15 @@ NMAccessPoint::NMAccessPoint(const QString& path, QObject* parent): QObject(pare
 	);
 
 	if (!this->proxy->isValid()) {
-		qCWarning(logNetworkManager) << "Cannot create DBus interface for AP at" << path;
+		qCWarning(logNetworkManager) << "Cannot create DBus interface for access point at" << path;
 		return;
 	}
 
 	QObject::connect(
 	    &this->accessPointProperties,
 	    &DBusPropertyGroup::getAllFinished,
 	    this,
-	    &NMAccessPoint::ready,
+	    &NMAccessPoint::loaded,
 	    Qt::SingleShotConnection
 	);
 

src/network/nm/accesspoint.hpp

@@ -7,6 +7,7 @@
 #include <qtypes.h>
 
 #include "../../dbus/properties.hpp"
+#include "../wifi.hpp"
 #include "enums.hpp"
 #include "nm/dbus_nm_accesspoint.h"
 
@@ -53,27 +54,29 @@ class NMAccessPoint: public QObject {
 	[[nodiscard]] NM80211ApSecurityFlags::Enum wpaFlags() const { return this->bWpaFlags; };
 	[[nodiscard]] NM80211ApSecurityFlags::Enum rsnFlags() const { return this->bRsnFlags; };
 	[[nodiscard]] NM80211Mode::Enum mode() const { return this->bMode; };
+	[[nodiscard]] QBindable<WifiSecurityType::Enum> bindableSecurity() { return &this->bSecurity; };
+	[[nodiscard]] WifiSecurityType::Enum security() const { return this->bSecurity; };
 
 signals:
-	void ready();
+	void loaded();
 	void disappeared();
 	void ssidChanged(const QByteArray& ssid);
 	void signalStrengthChanged(quint8 signal);
 	void flagsChanged(NM80211ApFlags::Enum flags);
 	void wpaFlagsChanged(NM80211ApSecurityFlags::Enum wpaFlags);
 	void rsnFlagsChanged(NM80211ApSecurityFlags::Enum rsnFlags);
 	void modeChanged(NM80211Mode::Enum mode);
+	void securityChanged(WifiSecurityType::Enum security);
 
 private:
-	bool mActive = false;
-
 	// clang-format off
 	Q_OBJECT_BINDABLE_PROPERTY(NMAccessPoint, QByteArray, bSsid, &NMAccessPoint::ssidChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMAccessPoint, quint8, bSignalStrength, &NMAccessPoint::signalStrengthChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMAccessPoint, NM80211ApFlags::Enum, bFlags, &NMAccessPoint::flagsChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMAccessPoint, NM80211ApSecurityFlags::Enum, bWpaFlags, &NMAccessPoint::wpaFlagsChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMAccessPoint, NM80211ApSecurityFlags::Enum, bRsnFlags, &NMAccessPoint::rsnFlagsChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMAccessPoint, NM80211Mode::Enum, bMode, &NMAccessPoint::modeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NMAccessPoint, WifiSecurityType::Enum, bSecurity, &NMAccessPoint::securityChanged);
 
 	QS_DBUS_BINDABLE_PROPERTY_GROUP(NMAccessPointAdapter, accessPointProperties);
 	QS_DBUS_PROPERTY_BINDING(NMAccessPoint, pSsid, bSsid, accessPointProperties, "Ssid");

src/network/nm/backend.cpp

@@ -10,14 +10,15 @@
 #include <qloggingcategory.h>
 #include <qobject.h>
 #include <qtmetamacros.h>
-#include <qxmlstream.h>
 
 #include "../../core/logcat.hpp"
 #include "../../dbus/properties.hpp"
 #include "../device.hpp"
 #include "../network.hpp"
 #include "../wifi.hpp"
 #include "dbus_types.hpp"
+#include "device.hpp"
+#include "enums.hpp"
 #include "nm/dbus_nm_backend.h"
 #include "wireless.hpp"
 
@@ -86,101 +87,132 @@ void NetworkManager::registerDevices() {
 }
 
 void NetworkManager::registerDevice(const QString& path) {
-	if (this->mDeviceHash.contains(path)) {
+	if (this->mDevices.contains(path)) {
 		qCDebug(logNetworkManager) << "Skipping duplicate registration of device" << path;
 		return;
 	}
 
-	// Introspect to decide the device variant. (For now, only Wireless)
-	auto* introspection = new QDBusInterface(
+	// Create a temporary interface to decide the device type which won't change.
+	auto* temp = new QDBusInterface(
 	    "org.freedesktop.NetworkManager",
 	    path,
-	    "org.freedesktop.DBus.Introspectable",
+	    "org.freedesktop.DBus.Properties",
 	    QDBusConnection::systemBus(),
 	    this
 	);
 
-	auto pending = introspection->asyncCall("Introspect");
+	auto pending = temp->asyncCall("Get", "org.freedesktop.NetworkManager.Device", "DeviceType");
 	auto* call = new QDBusPendingCallWatcher(pending, this);
 
-	auto responseCallback = [this, path, introspection](QDBusPendingCallWatcher* call) {
-		const QDBusPendingReply<QString> reply = *call;
-
+	auto responseCallback = [this, path, temp](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<QVariant> reply = *call;
 		if (reply.isError()) {
-			qCWarning(logNetworkManager) << "Failed to introspect device: " << reply.error().message();
+			qCWarning(logNetworkManager) << "Failed to get device type: " << reply.error().message();
 		} else {
-			QXmlStreamReader xml(reply.value());
-
-			while (!xml.atEnd() && !xml.hasError()) {
-				xml.readNext();
-
-				if (xml.isStartElement() && xml.name() == u"interface") {
-					const QString name = xml.attributes().value("name").toString();
-					if (name.startsWith("org.freedesktop.NetworkManager.Device.Wireless")) {
-						this->registerWifiDevice(path);
-						break;
-					}
-				}
+			auto type = static_cast<qs::network::NMDeviceType::Enum>(reply.value().toInt());
+			NMDevice* dev = nullptr;
+
+			switch (type) {
+			case NMDeviceType::Wifi: dev = new NMWirelessDevice(path); break;
+			default: return;
+			}
+
+			if (!dev->isValid()) {
+				qCWarning(logNetworkManager) << "Ignoring invalid registration of" << path;
+				delete dev;
+				return;
 			}
+
+			// Only register a frontend device while it's managed by NM.
+			auto onManagedChanged = [this, dev, type](bool managed) {
+				managed ? this->registerFrontendDevice(type, dev) : this->removeFrontendDevice(dev);
+			};
+			// clang-format off
+			QObject::connect(dev, &NMDevice::addAndActivateConnection, this, &NetworkManager::addAndActivateConnection);
+			QObject::connect(dev, &NMDevice::activateConnection, this, &NetworkManager::activateConnection);
+			QObject::connect(dev, &NMDevice::managedChanged, this, onManagedChanged);
+			// clang-format on
+
+			this->mDevices.insert(path, dev);
+			if (dev->managed()) this->registerFrontendDevice(type, dev);
 		}
 		delete call;
-		delete introspection;
+		delete temp;
 	};
 
 	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
 }
 
-void NetworkManager::registerWifiDevice(const QString& path) {
-	auto* wireless = new NMWirelessDevice(path);
-	if (!wireless->isWirelessValid() || !wireless->isDeviceValid()) {
-		qCWarning(logNetworkManager) << "Ignoring invalid registration of" << path;
-		delete wireless;
-		return;
+void NetworkManager::registerFrontendDevice(NMDeviceType::Enum type, NMDevice* dev) {
+	NetworkDevice* frontendDev = nullptr;
+	switch (type) {
+	case NMDeviceType::Wifi: {
+		auto* frontendWifiDev = new WifiDevice(dev);
+		auto* wifiDev = qobject_cast<NMWirelessDevice*>(dev);
+		// Bind WifiDevice-specific properties
+		auto translateMode = [wifiDev]() {
+			switch (wifiDev->mode()) {
+			case NM80211Mode::Unknown: return WifiDeviceMode::Unknown;
+			case NM80211Mode::Adhoc: return WifiDeviceMode::AdHoc;
+			case NM80211Mode::Infra: return WifiDeviceMode::Station;
+			case NM80211Mode::Ap: return WifiDeviceMode::AccessPoint;
+			case NM80211Mode::Mesh: return WifiDeviceMode::Mesh;
+			}
+		};
+		// clang-format off
+		frontendWifiDev->bindableMode().setBinding(translateMode);
+		wifiDev->bindableScanning().setBinding([frontendWifiDev]() { return frontendWifiDev->wifiScanner()->enabled(); });
+		QObject::connect(wifiDev, &NMWirelessDevice::networkAdded, frontendWifiDev, &WifiDevice::networkAdded);
+		QObject::connect(wifiDev, &NMWirelessDevice::networkRemoved, frontendWifiDev, &WifiDevice::networkRemoved);
+		// clang-format on
+		frontendDev = frontendWifiDev;
+		break;
+	}
+	default: return;
 	}
 
-	auto* device = new WifiDevice(this);
-	auto* scanner = device->wifiScanner();
-	wireless->setParent(device);
-	this->mDeviceHash.insert(path, device);
-
-	device->bindableName().setBinding([wireless]() { return wireless->interface(); });
-	device->bindableAddress().setBinding([wireless]() { return wireless->hwAddress(); });
-	device->bindableNmState().setBinding([wireless]() { return wireless->state(); });
-	device->bindableState().setBinding([wireless]() {
-		switch (wireless->state()) {
+	// Bind generic NetworkDevice properties
+	auto translateState = [dev]() {
+		switch (dev->state()) {
 		case 0 ... 20: return DeviceConnectionState::Unknown;
 		case 30: return DeviceConnectionState::Disconnected;
 		case 40 ... 90: return DeviceConnectionState::Connecting;
 		case 100: return DeviceConnectionState::Connected;
 		case 110 ... 120: return DeviceConnectionState::Disconnecting;
 		}
-	});
-	// clang-format off
-	QObject::connect(wireless, &NMWirelessDevice::addAndActivateConnection, this, &NetworkManager::addAndActivateConnection);
-	QObject::connect(wireless, &NMWirelessDevice::activateConnection, this, &NetworkManager::activateConnection);
-	QObject::connect(wireless, &NMWirelessDevice::networkAdded, device, &WifiDevice::networkAdded);
-	QObject::connect(wireless, &NMWirelessDevice::networkRemoved, device, &WifiDevice::networkRemoved);
-	QObject::connect(scanner, &WifiScanner::requestEnabled, wireless, &NMWirelessDevice::handleScanner);
-	QObject::connect(device, &WifiDevice::requestDisconnect, wireless, &NMWirelessDevice::disconnect);
-	// clang-format on
+	};
+	frontendDev->bindableName().setBinding([dev]() { return dev->interface(); });
+	frontendDev->bindableAddress().setBinding([dev]() { return dev->hwAddress(); });
+	frontendDev->bindableNmState().setBinding([dev]() { return dev->state(); });
+	frontendDev->bindableState().setBinding(translateState);
+	QObject::connect(frontendDev, &WifiDevice::requestDisconnect, dev, &NMDevice::disconnect);
+
+	this->mFrontendDevices.insert(dev->path(), frontendDev);
+	emit this->deviceAdded(frontendDev);
+}
 
-	emit this->deviceAdded(device);
+void NetworkManager::removeFrontendDevice(NMDevice* dev) {
+	auto* frontendDev = this->mFrontendDevices.take(dev->path());
+	if (frontendDev) {
+		emit this->deviceRemoved(frontendDev);
+		delete frontendDev;
+	}
 }
 
 void NetworkManager::onDevicePathAdded(const QDBusObjectPath& path) {
 	this->registerDevice(path.path());
 }
 
 void NetworkManager::onDevicePathRemoved(const QDBusObjectPath& path) {
-	auto iter = this->mDeviceHash.find(path.path());
-	if (iter == this->mDeviceHash.end()) {
+	auto iter = this->mDevices.find(path.path());
+	if (iter == this->mDevices.end()) {
 		qCWarning(logNetworkManager) << "Sent removal signal for" << path.path()
 		                             << "which is not registered.";
 	} else {
-		auto* device = iter.value();
-		this->mDeviceHash.erase(iter);
-		emit this->deviceRemoved(device);
-		delete device;
+		auto* dev = iter.value();
+		this->removeFrontendDevice(dev);
+		this->mDevices.erase(iter);
+		delete dev;
 	}
 }
 

src/network/nm/backend.hpp

@@ -9,7 +9,7 @@
 
 #include "../../dbus/properties.hpp"
 #include "../network.hpp"
-#include "../wifi.hpp"
+#include "device.hpp"
 #include "nm/dbus_nm_backend.h"
 
 namespace qs::network {
@@ -47,9 +47,11 @@ private slots:
 	void init();
 	void registerDevices();
 	void registerDevice(const QString& path);
-	void registerWifiDevice(const QString& path);
+	void registerFrontendDevice(NMDeviceType::Enum type, NMDevice* dev);
+	void removeFrontendDevice(NMDevice* dev);
 
-	QHash<QString, NetworkDevice*> mDeviceHash;
+	QHash<QString, NMDevice*> mDevices;
+	QHash<QString, NetworkDevice*> mFrontendDevices;
 
 	// clang-format off
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkManager, bool, bWifiEnabled, &NetworkManager::wifiEnabledChanged);

src/network/nm/connection.cpp

@@ -19,6 +19,7 @@
 #include "enums.hpp"
 #include "nm/dbus_nm_active_connection.h"
 #include "nm/dbus_nm_connection_settings.h"
+#include "nm/utils.hpp"
 
 namespace qs::network {
 using namespace qs::dbus;
@@ -48,6 +49,7 @@ NMConnectionSettings::NMConnectionSettings(const QString& path, QObject* parent)
 	    this,
 	    &NMConnectionSettings::updateSettings
 	);
+	this->bSecurity.setBinding([this]() { return securityFromConnectionSettings(this->bSettings); });
 
 	this->connectionSettingsProperties.setInterface(this->proxy);
 	this->connectionSettingsProperties.updateAllViaGetAll();
@@ -69,7 +71,10 @@ void NMConnectionSettings::updateSettings() {
 			this->bSettings = reply.value();
 		}
 
-		emit this->ready();
+		if (!this->mLoaded) {
+			emit this->loaded();
+			this->mLoaded = true;
+		}
 		delete call;
 	};
 
@@ -96,7 +101,7 @@ NMActiveConnection::NMActiveConnection(const QString& path, QObject* parent): QO
 	}
 
 	// clang-format off
-	QObject::connect(&this->activeConnectionProperties, &DBusPropertyGroup::getAllFinished, this, &NMActiveConnection::ready, Qt::SingleShotConnection);
+	QObject::connect(&this->activeConnectionProperties, &DBusPropertyGroup::getAllFinished, this, &NMActiveConnection::loaded, Qt::SingleShotConnection);
 	QObject::connect(this->proxy, &DBusNMActiveConnectionProxy::StateChanged, this, &NMActiveConnection::onStateChanged);
 	// clang-format on