network: NMConnection, Network.nmConnections, Network.nmDefaultConnection

Author: cpwrs

src/network/CMakeLists.txt

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

src/network/connection.cpp

@@ -0,0 +1,20 @@
+#include "connection.hpp"
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "nm/types.hpp"
+
+namespace qs::network {
+
+NMConnection::NMConnection(QObject* parent): QObject(parent) {}
+
+void NMConnection::updateSettings(const ConnectionSettingsMap& settings) {
+	emit this->requestUpdateSettings(settings);
+}
+
+void NMConnection::clearSecrets() { emit this->requestClearSecrets(); }
+
+void NMConnection::forget() { emit this->requestForget(); }
+
+} // namespace qs::network

src/network/connection.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtypes.h>
+
+#include "nm/types.hpp"
+
+namespace qs::network {
+
+///! A NetworkManager connection settings profile.
+class NMConnection: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("");
+
+	// clang-format off
+	/// A settings map describing this network configuration.
+	Q_PROPERTY(ConnectionSettingsMap settings READ default NOTIFY settingsChanged BINDABLE bindableSettings);
+	/// A settings map describing the secrets belonging to this network configuration.
+	Q_PROPERTY(ConnectionSettingsMap secretSettings READ default NOTIFY secretSettingsChanged BINDABLE bindableSecretSettings);
+	/// A human readable unique identifier for the connection.
+	Q_PROPERTY(QString id READ default NOTIFY idChanged BINDABLE bindableId);
+	// clang-format on
+
+public:
+	explicit NMConnection(QObject* parent = nullptr);
+	/// Attempt to update the connection with new settings and save the connection to disk. Secrets may be a part of the update request,
+	/// and will either be stored in persistent storage tor sent to a Secret Agent for storage, depending on the flags
+	/// associated with each secret and the presence of a registered Secret Agent.
+	Q_INVOKABLE void updateSettings(const ConnectionSettingsMap& settings);
+	/// Attempt to clear all of the secrets belonging to this connection.
+	Q_INVOKABLE void clearSecrets();
+	/// Delete the connection.
+	Q_INVOKABLE void forget();
+
+	QBindable<ConnectionSettingsMap> bindableSettings() { return &this->bSettings; }
+	QBindable<ConnectionSettingsMap> bindableSecretSettings() { return &this->bSecretSettings; }
+	QBindable<QString> bindableId() { return &this->bId; }
+
+signals:
+	void requestUpdateSettings(ConnectionSettingsMap settings);
+	void requestClearSecrets();
+	void requestForget();
+	void settingsChanged();
+	void secretSettingsChanged();
+	void idChanged();
+
+private:
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(NMConnection, ConnectionSettingsMap, bSettings, &NMConnection::settingsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NMConnection, ConnectionSettingsMap, bSecretSettings, &NMConnection::secretSettingsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NMConnection, QString, bId, &NMConnection::idChanged);
+	// clang-format on
+};
+} // namespace qs::network

src/network/device.cpp

@@ -66,6 +66,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

@@ -85,9 +85,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 +110,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 +137,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/network.cpp

@@ -8,6 +8,7 @@
 #include <qtmetamacros.h>
 
 #include "../core/logcat.hpp"
+#include "connection.hpp"
 #include "device.hpp"
 #include "nm/backend.hpp"
 
@@ -27,6 +28,37 @@ QString NetworkState::toString(NetworkState::Enum state) {
 	}
 }
 
+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");
+	};
+};
+
 Networking::Networking(QObject* parent): QObject(parent) {
 	// Try to create the NetworkManager backend and bind to it.
 	auto* nm = new NetworkManager(this);
@@ -62,4 +94,33 @@ Network::Network(QString name, QObject* parent): QObject(parent), mName(std::mov
 	});
 };
 
+void Network::setNmDefaultConnection(NMConnection* conn) {
+	if (this->bNmDefaultConnection == conn) return;
+	if (!this->mNmConnections.valueList().contains(conn)) return;
+	emit this->requestSetNmDefaultConnection(conn);
+}
+
+void Network::connect() {
+	if (this->bConnected) {
+		qCCritical(logNetwork) << this << "is already connected.";
+		return;
+	}
+
+	this->requestConnect();
+}
+
+void Network::disconnect() {
+	if (!this->bConnected) {
+		qCCritical(logNetwork) << this << "is not currently connected";
+		return;
+	}
+
+	this->requestDisconnect();
+}
+
+void Network::forget() { this->requestForget(); }
+
+void Network::connectionAdded(NMConnection* conn) { this->mNmConnections.insertObject(conn); }
+void Network::connectionRemoved(NMConnection* conn) { this->mNmConnections.removeObject(conn); }
+
 } // namespace qs::network

src/network/network.hpp

@@ -7,6 +7,7 @@
 #include <qtypes.h>
 
 #include "../core/model.hpp"
+#include "connection.hpp"
 #include "device.hpp"
 
 namespace qs::network {
@@ -29,6 +30,35 @@ class NetworkState: public QObject {
 	Q_INVOKABLE static QString toString(NetworkState::Enum state);
 };
 
+///! The reason for the NMConnectionState of an NMConnection.
+/// In sync with https://networkmanager.dev/docs/api/latest/nm-dbus-types.html#NMActiveConnectionStateReason.
+class NMNetworkStateReason: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Unknown = 0,
+		None = 1,
+		UserDisconnected = 2,
+		DeviceDisconnected = 3,
+		ServiceStopped = 4,
+		IpConfigInvalid = 5,
+		ConnectTimeout = 6,
+		ServiceStartTimeout = 7,
+		ServiceStartFailed = 8,
+		NoSecrets = 9,
+		LoginFailed = 10,
+		ConnectionRemoved = 11,
+		DependencyFailed = 12,
+		DeviceRealizeFailed = 13,
+		DeviceRemoved = 14
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(NMNetworkStateReason::Enum reason);
+};
+
 ///! The backend supplying the Network service.
 class NetworkBackendType: public QObject {
 	Q_OBJECT;
@@ -105,38 +135,81 @@ private slots:
 class Network: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
-	QML_UNCREATABLE("BaseNetwork can only be aqcuired through network devices");
+	QML_UNCREATABLE("Network can only be aqcuired through networking devices");
 
 	// clang-format off
 	/// The name of the network.
 	Q_PROPERTY(QString name READ name CONSTANT);
+	/// A list of connnection settings profiles for this network.
+	///
+	/// > [!WARNING] Only valid for the NetworkManager backend. 
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::network::NMConnection>*);
+	Q_PROPERTY(UntypedObjectModel* nmConnections READ nmConnections CONSTANT);
+	/// The default connection settings profile for this network. This is the connection settings used when connect() is invoked.
+	/// Only available when the connection is known.
+	///
+	/// > [!WARNING] Only valid for the NetworkManager backend.
+	Q_PROPERTY(NMConnection* nmDefaultConnection READ nmDefaultConnection WRITE setNmDefaultConnection NOTIFY nmDefaultConnectionChanged BINDABLE bindableNmDefaultConnection);
 	/// True if the network is connected.
 	Q_PROPERTY(bool connected READ default NOTIFY connectedChanged BINDABLE bindableConnected);
+	/// True if the wifi network has known connection settings saved.
+	Q_PROPERTY(bool known READ default NOTIFY knownChanged BINDABLE bindableKnown);
 	/// The connectivity state of the network.
 	Q_PROPERTY(NetworkState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	/// A specific reason for the connection state. Only available for the NetworkManager backend.
+	Q_PROPERTY(NMNetworkStateReason::Enum stateReason READ default NOTIFY stateReasonChanged BINDABLE bindableStateReason);
 	/// If the network is currently connecting or disconnecting. Shorthand for checking @@state.
 	Q_PROPERTY(bool stateChanging READ default NOTIFY stateChangingChanged BINDABLE bindableStateChanging);
 	// clang-format on
 
 public:
 	explicit Network(QString name, QObject* parent = nullptr);
 
+	/// Attempt to connect to the network.
+	Q_INVOKABLE void connect();
+	/// Disconnect from the network.
+	Q_INVOKABLE void disconnect();
+	/// Forget all connection settings for this network.
+	Q_INVOKABLE void forget();
+
+	void connectionAdded(NMConnection* conn);
+	void connectionRemoved(NMConnection* conn);
+
 	[[nodiscard]] QString name() const { return this->mName; };
+	[[nodiscard]] ObjectModel<NMConnection>* nmConnections() { return &this->mNmConnections; };
+	[[nodiscard]] NMConnection* nmDefaultConnection() { return this->bNmDefaultConnection; };
+	QBindable<NMConnection*> bindableNmDefaultConnection() { return &this->bNmDefaultConnection; };
+	void setNmDefaultConnection(NMConnection* conn);
 	QBindable<bool> bindableConnected() { return &this->bConnected; }
+	QBindable<bool> bindableKnown() { return &this->bKnown; }
 	QBindable<NetworkState::Enum> bindableState() { return &this->bState; }
+	QBindable<NMNetworkStateReason::Enum> bindableStateReason() { return &this->bStateReason; }
 	QBindable<bool> bindableStateChanging() { return &this->bStateChanging; }
 
 signals:
+	void requestSetNmDefaultConnection(NMConnection* conn);
+	void requestConnect();
+	void requestDisconnect();
+	void requestForget();
+	void nmDefaultConnectionChanged();
 	void connectedChanged();
+	void knownChanged();
 	void stateChanged();
+	void stateReasonChanged();
 	void stateChangingChanged();
 
 protected:
 	QString mName;
+	ObjectModel<NMConnection> mNmConnections {this};
 
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(Network, NMConnection*, bNmDefaultConnection, &Network::nmDefaultConnectionChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bConnected, &Network::connectedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bKnown, &Network::knownChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(Network, NetworkState::Enum, bState, &Network::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Network, NMNetworkStateReason::Enum, bStateReason, &Network::stateReasonChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bStateChanging, &Network::stateChangingChanged);
+	// clang-format on
 };
 
 } // namespace qs::network

src/network/nm/CMakeLists.txt

@@ -1,7 +1,7 @@
 set_source_files_properties(org.freedesktop.NetworkManager.xml PROPERTIES
 	CLASSNAME DBusNetworkManagerProxy
 	NO_NAMESPACE TRUE
-	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/dbus_types.hpp
+	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/types.hpp
 )
 
 qt_add_dbus_interface(NM_DBUS_INTERFACES
@@ -42,7 +42,7 @@ qt_add_dbus_interface(NM_DBUS_INTERFACES
 set_source_files_properties(org.freedesktop.NetworkManager.Settings.Connection.xml PROPERTIES
 	CLASSNAME DBusNMConnectionSettingsProxy
 	NO_NAMESPACE TRUE
-	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/dbus_types.hpp
+	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/types.hpp
 )
 
 qt_add_dbus_interface(NM_DBUS_INTERFACES