network: add NMConnection and NMConnectionContext

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,53 +8,14 @@
 #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;
@@ -66,6 +27,11 @@ 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) {
 		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";

src/network/device.hpp

@@ -6,67 +6,9 @@
 #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 "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.
@@ -85,9 +27,15 @@ class NetworkDevice: public QObject {
 	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.
+	/// A more specific device state.
+	///
+	/// > [!WARNING] Only valid for the NetworkManager backend. 
 	Q_PROPERTY(qs::network::NMDeviceState::Enum nmState READ default NOTIFY nmStateChanged BINDABLE bindableNmState);
-	/// True if the device is allowed to autoconnect.
+	/// 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
 
@@ -104,18 +52,23 @@ class NetworkDevice: public QObject {
 	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> 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);
+	void requestSetNmManaged(bool managed);
 	void nameChanged();
 	void addressChanged();
 	void connectedChanged();
 	void stateChanged();
 	void nmStateChanged();
+	void nmManagedChanged();
 	void autoconnectChanged();
 
 private:
@@ -126,6 +79,7 @@ class NetworkDevice: public QObject {
 	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, bool, bNmManaged, &NetworkDevice::nmManagedChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, bool, bAutoconnect, &NetworkDevice::autoconnectChanged);
 	// clang-format on
 };

src/network/enums.cpp

@@ -0,0 +1,117 @@
+#include "enums.hpp"
+
+#include <qstring.h>
+
+namespace qs::network {
+
+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");
+	};
+}
+
+QString NetworkState::toString(NetworkState::Enum state) {
+	switch (state) {
+	case NetworkState::Connecting: return QStringLiteral("Connecting");
+	case NetworkState::Connected: return QStringLiteral("Connected");
+	case NetworkState::Disconnecting: return QStringLiteral("Disconnecting");
+	case NetworkState::Disconnected: return QStringLiteral("Disconnected");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString NMNetworkStateReason::toString(NMNetworkStateReason::Enum reason) {
+	switch (reason) {
+	case Unknown: return QStringLiteral("Unknown");
+	case None: return QStringLiteral("No reason");
+	case UserDisconnected: return QStringLiteral("User disconnection");
+	case DeviceDisconnected:
+		return QStringLiteral("The device the connection was using was disconnected.");
+	case ServiceStopped:
+		return QStringLiteral("The service providing the VPN connection was stopped.");
+	case IpConfigInvalid:
+		return QStringLiteral("The IP config of the active connection was invalid.");
+	case ConnectTimeout:
+		return QStringLiteral("The connection attempt to the VPN service timed out.");
+	case ServiceStartTimeout:
+		return QStringLiteral(
+		    "A timeout occurred while starting the service providing the VPN connection."
+		);
+	case ServiceStartFailed:
+		return QStringLiteral("Starting the service providing the VPN connection failed.");
+	case NoSecrets: return QStringLiteral("Necessary secrets for the connection were not provided.");
+	case LoginFailed: return QStringLiteral("Authentication to the server failed.");
+	case ConnectionRemoved:
+		return QStringLiteral("Necessary secrets for the connection were not provided.");
+	case DependencyFailed:
+		return QStringLiteral("Master connection of this connection failed to activate.");
+	case DeviceRealizeFailed: return QStringLiteral("Could not create the software device link.");
+	case DeviceRemoved: return QStringLiteral("The device this connection depended on disappeared.");
+	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