network: add NMSettings and connectWithPsk/Settings

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.20)
 project(quickshell VERSION "0.2.1" LANGUAGES CXX C)
 
-set(UNRELEASED_FEATURES)
+set(UNRELEASED_FEATURES "network.2")
 
 set(QT_MIN_VERSION "6.6.0")
 set(CMAKE_CXX_STANDARD 20)

changelog/next.md

@@ -20,7 +20,7 @@ set shell id.
 - Added the ability to handle move and resize events to FloatingWindow.
 - Pipewire service now reconnects if pipewire dies or a protocol error occurs.
 - Added pipewire audio peak detection.
-- Added initial support for network management.
+- Added network management support.
 - Added support for grabbing focus from popup windows.
 - Added support for IPC signal listeners.
 - Added Quickshell version checking and version gated preprocessing.

src/network/CMakeLists.txt

@@ -4,6 +4,7 @@ qt_add_library(quickshell-network STATIC
 	network.cpp
 	device.cpp
 	wifi.cpp
+	enums.cpp
 )
 
 target_include_directories(quickshell-network PRIVATE 

src/network/device.cpp

@@ -8,56 +8,17 @@
 #include <qtmetamacros.h>
 
 #include "../core/logcat.hpp"
+#include "enums.hpp"
 
 namespace qs::network {
 
 namespace {
 QS_LOGGING_CATEGORY(logNetworkDevice, "quickshell.network.device", QtWarningMsg);
 } // namespace
 
-QString DeviceConnectionState::toString(DeviceConnectionState::Enum state) {
-	switch (state) {
-	case Unknown: return QStringLiteral("Unknown");
-	case Connecting: return QStringLiteral("Connecting");
-	case Connected: return QStringLiteral("Connected");
-	case Disconnecting: return QStringLiteral("Disconnecting");
-	case Disconnected: return QStringLiteral("Disconnected");
-	default: return QStringLiteral("Unknown");
-	}
-}
-
-QString DeviceType::toString(DeviceType::Enum type) {
-	switch (type) {
-	case None: return QStringLiteral("None");
-	case Wifi: return QStringLiteral("Wifi");
-	default: return QStringLiteral("Unknown");
-	}
-}
-
-QString NMDeviceState::toString(NMDeviceState::Enum state) {
-	switch (state) {
-	case Unknown: return QStringLiteral("Unknown");
-	case Unmanaged: return QStringLiteral("Not managed by NetworkManager");
-	case Unavailable: return QStringLiteral("Unavailable");
-	case Disconnected: return QStringLiteral("Disconnected");
-	case Prepare: return QStringLiteral("Preparing to connect");
-	case Config: return QStringLiteral("Connecting to a network");
-	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 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");
-	case Deactivating: return QStringLiteral("Disconnecting");
-	case Failed: return QStringLiteral("Failed to connect");
-	default: return QStringLiteral("Unknown");
-	};
-}
-
 NetworkDevice::NetworkDevice(DeviceType::Enum type, QObject* parent): QObject(parent), mType(type) {
 	this->bindableConnected().setBinding([this]() {
-		return this->bState == DeviceConnectionState::Connected;
+		return this->bState == ConnectionState::Connected;
 	});
 };
 
@@ -66,12 +27,17 @@ void NetworkDevice::setAutoconnect(bool autoconnect) {
 	emit this->requestSetAutoconnect(autoconnect);
 }
 
+void NetworkDevice::setNmManaged(bool managed) {
+	if (this->bNmManaged == managed) return;
+	emit this->requestSetNmManaged(managed);
+}
+
 void NetworkDevice::disconnect() {
-	if (this->bState == DeviceConnectionState::Disconnected) {
+	if (this->bState == ConnectionState::Disconnected) {
 		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
 		return;
 	}
-	if (this->bState == DeviceConnectionState::Disconnecting) {
+	if (this->bState == ConnectionState::Disconnecting) {
 		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
 		return;
 	}

src/network/device.hpp

@@ -6,76 +6,22 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
-namespace qs::network {
-
-///! Connection state of a NetworkDevice.
-class DeviceConnectionState: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
-
-public:
-	enum Enum : quint8 {
-		Unknown = 0,
-		Connecting = 1,
-		Connected = 2,
-		Disconnecting = 3,
-		Disconnected = 4,
-	};
-	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(DeviceConnectionState::Enum state);
-};
-
-///! Type of network device.
-class DeviceType: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
+#include "../core/doc.hpp"
+#include "enums.hpp"
 
-public:
-	enum Enum : quint8 {
-		None = 0,
-		Wifi = 1,
-	};
-	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(DeviceType::Enum type);
-};
-
-///! NetworkManager-specific device state.
-/// In sync with https://networkmanager.dev/docs/api/latest/nm-dbus-types.html#NMDeviceState.
-class NMDeviceState: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
-
-public:
-	enum Enum : quint8 {
-		Unknown = 0,
-		Unmanaged = 10,
-		Unavailable = 20,
-		Disconnected = 30,
-		Prepare = 40,
-		Config = 50,
-		NeedAuth = 60,
-		IPConfig = 70,
-		IPCheck = 80,
-		Secondaries = 90,
-		Activated = 100,
-		Deactivating = 110,
-		Failed = 120,
-	};
-	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(NMDeviceState::Enum state);
-};
+namespace qs::network {
 
 ///! A network device.
-/// When @@type is `Wifi`, the device is a @@WifiDevice, which can be used to scan for and connect to access points.
+/// The @@type property may be used to determine if this device is a @@WifiDevice.
 class NetworkDevice: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
 	QML_UNCREATABLE("Devices can only be acquired through Network");
 	// clang-format off
 	/// The device type.
+	///
+	/// When the device type is `Wifi`, the device object is a @@WifiDevice which exposes wifi network
+	/// connection and scanning.
 	Q_PROPERTY(DeviceType::Enum type READ type CONSTANT);
 	/// The name of the device's control interface.
 	Q_PROPERTY(QString name READ name NOTIFY nameChanged BINDABLE bindableName);
@@ -84,10 +30,12 @@ class NetworkDevice: public QObject {
 	/// True if the device is connected.
 	Q_PROPERTY(bool connected READ default NOTIFY connectedChanged BINDABLE bindableConnected);
 	/// Connection state of the device.
-	Q_PROPERTY(qs::network::DeviceConnectionState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
-	/// A more specific device state when the backend is NetworkManager.
-	Q_PROPERTY(qs::network::NMDeviceState::Enum nmState READ default NOTIFY nmStateChanged BINDABLE bindableNmState);
-	/// True if the device is allowed to autoconnect.
+	Q_PROPERTY(qs::network::ConnectionState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	/// True if the device is managed by NetworkManager.
+	///
+	/// > [!WARNING] Only valid for the NetworkManager backend.
+	Q_PROPERTY(bool nmManaged READ nmManaged WRITE setNmManaged NOTIFY nmManagedChanged)
+	/// True if the device is allowed to autoconnect to a network.
 	Q_PROPERTY(bool autoconnect READ autoconnect WRITE setAutoconnect NOTIFY autoconnectChanged);
 	// clang-format on
 
@@ -97,25 +45,28 @@ class NetworkDevice: public QObject {
 	/// Disconnects the device and prevents it from automatically activating further connections.
 	Q_INVOKABLE void disconnect();
 
-	[[nodiscard]] DeviceType::Enum type() const { return this->mType; };
-	QBindable<QString> bindableName() { return &this->bName; };
-	[[nodiscard]] QString name() const { return this->bName; };
-	QBindable<QString> bindableAddress() { return &this->bAddress; };
-	QBindable<bool> bindableConnected() { return &this->bConnected; };
-	QBindable<DeviceConnectionState::Enum> bindableState() { return &this->bState; };
-	QBindable<NMDeviceState::Enum> bindableNmState() { return &this->bNmState; };
-	[[nodiscard]] bool autoconnect() const { return this->bAutoconnect; };
-	QBindable<bool> bindableAutoconnect() { return &this->bAutoconnect; };
+	[[nodiscard]] DeviceType::Enum type() const { return this->mType; }
+	QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QString name() const { return this->bName; }
+	QBindable<QString> bindableAddress() { return &this->bAddress; }
+	QBindable<bool> bindableConnected() { return &this->bConnected; }
+	QBindable<ConnectionState::Enum> bindableState() { return &this->bState; }
+	QBindable<bool> bindableNmManaged() { return &this->bNmManaged; }
+	[[nodiscard]] bool nmManaged() { return this->bNmManaged; }
+	void setNmManaged(bool managed);
+	QBindable<bool> bindableAutoconnect() { return &this->bAutoconnect; }
+	[[nodiscard]] bool autoconnect() { return this->bAutoconnect; }
 	void setAutoconnect(bool autoconnect);
 
 signals:
-	void requestDisconnect();
-	void requestSetAutoconnect(bool autoconnect);
+	QSDOC_HIDE void requestDisconnect();
+	QSDOC_HIDE void requestSetAutoconnect(bool autoconnect);
+	QSDOC_HIDE void requestSetNmManaged(bool managed);
 	void nameChanged();
 	void addressChanged();
 	void connectedChanged();
 	void stateChanged();
-	void nmStateChanged();
+	void nmManagedChanged();
 	void autoconnectChanged();
 
 private:
@@ -124,8 +75,8 @@ class NetworkDevice: public QObject {
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bName, &NetworkDevice::nameChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bAddress, &NetworkDevice::addressChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, bool, bConnected, &NetworkDevice::connectedChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, DeviceConnectionState::Enum, bState, &NetworkDevice::stateChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, NMDeviceState::Enum, bNmState, &NetworkDevice::nmStateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, ConnectionState::Enum, bState, &NetworkDevice::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, bool, bNmManaged, &NetworkDevice::nmManagedChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, bool, bAutoconnect, &NetworkDevice::autoconnectChanged);
 	// clang-format on
 };

src/network/enums.cpp

@@ -0,0 +1,86 @@
+#include "enums.hpp"
+
+#include <qstring.h>
+
+namespace qs::network {
+
+QString NetworkConnectivity::toString(NetworkConnectivity::Enum conn) {
+	switch (conn) {
+	case Unknown: return QStringLiteral("Unknown");
+	case None: return QStringLiteral("Not connected to a network");
+	case Portal: return QStringLiteral("Connection intercepted by a captive portal");
+	case Limited: return QStringLiteral("Partial internet connectivity");
+	case Full: return QStringLiteral("Full internet connectivity");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString NetworkBackendType::toString(NetworkBackendType::Enum type) {
+	switch (type) {
+	case NetworkBackendType::None: return "None";
+	case NetworkBackendType::NetworkManager: return "NetworkManager";
+	default: return "Unknown";
+	}
+}
+
+QString ConnectionState::toString(ConnectionState::Enum state) {
+	switch (state) {
+	case Unknown: return QStringLiteral("Unknown");
+	case Connecting: return QStringLiteral("Connecting");
+	case Connected: return QStringLiteral("Connected");
+	case Disconnecting: return QStringLiteral("Disconnecting");
+	case Disconnected: return QStringLiteral("Disconnected");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString ConnectionFailReason::toString(ConnectionFailReason::Enum reason) {
+	switch (reason) {
+	case Unknown: return QStringLiteral("Unknown");
+	case NoSecrets: return QStringLiteral("Secrets were required but not provided");
+	case WifiClientDisconnected: return QStringLiteral("Wi-Fi supplicant diconnected");
+	case WifiClientFailed: return QStringLiteral("Wi-Fi supplicant failed");
+	case WifiAuthTimeout: return QStringLiteral("Wi-Fi connection took too long to authenticate");
+	case WifiNetworkLost: return QStringLiteral("Wi-Fi network could not be found");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString DeviceType::toString(DeviceType::Enum type) {
+	switch (type) {
+	case None: return QStringLiteral("None");
+	case Wifi: return QStringLiteral("Wifi");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString WifiSecurityType::toString(WifiSecurityType::Enum type) {
+	switch (type) {
+	case Unknown: return QStringLiteral("Unknown");
+	case Wpa3SuiteB192: return QStringLiteral("WPA3 Suite B 192-bit");
+	case Sae: return QStringLiteral("WPA3");
+	case Wpa2Eap: return QStringLiteral("WPA2 Enterprise");
+	case Wpa2Psk: return QStringLiteral("WPA2");
+	case WpaEap: return QStringLiteral("WPA Enterprise");
+	case WpaPsk: return QStringLiteral("WPA");
+	case StaticWep: return QStringLiteral("WEP");
+	case DynamicWep: return QStringLiteral("Dynamic WEP");
+	case Leap: return QStringLiteral("LEAP");
+	case Owe: return QStringLiteral("OWE");
+	case Open: return QStringLiteral("Open");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString WifiDeviceMode::toString(WifiDeviceMode::Enum mode) {
+	switch (mode) {
+	case Unknown: return QStringLiteral("Unknown");
+	case AdHoc: return QStringLiteral("Ad-Hoc");
+	case Station: return QStringLiteral("Station");
+	case AccessPoint: return QStringLiteral("Access Point");
+	case Mesh: return QStringLiteral("Mesh");
+	default: return QStringLiteral("Unknown");
+	};
+}
+
+} // namespace qs::network