feat: NMWirelessNetwork holds all wifi network objects

Removes the NMWirelessManager and moves its functionality to the
NMWirelessDevice, which now extends NMDevice. NMWirelessNetworks hold
all of the state of the APs and connections and signals the best
settings for connection.

Author: cpwrs

src/network/CMakeLists.txt

@@ -2,6 +2,7 @@
 set_source_files_properties(nm/org.freedesktop.NetworkManager.xml PROPERTIES
 	CLASSNAME DBusNetworkManagerProxy
 	NO_NAMESPACE TRUE
+	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/nm/dbus_types.hpp
 )
 
 qt_add_dbus_interface(NM_DBUS_INTERFACES
@@ -41,6 +42,7 @@ qt_add_dbus_interface(NM_DBUS_INTERFACES
 
 set_source_files_properties(nm/org.freedesktop.NetworkManager.Settings.Connection.xml PROPERTIES
 	CLASSNAME DBusNMConnectionSettingsProxy
+	NO_NAMESPACE TRUE
 	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/nm/dbus_types.hpp
 )
 
@@ -60,7 +62,9 @@ qt_add_dbus_interface(NM_DBUS_INTERFACES
 )
 
 qt_add_library(quickshell-network STATIC
-	frontend.cpp
+	network.cpp
+	device.cpp
+	wifi.cpp
 	nm/backend.cpp
 	nm/device.cpp
 	nm/connection.cpp

src/network/device.cpp

@@ -0,0 +1,67 @@
+#include "device.hpp"
+
+#include <qdbusconnection.h>
+#include <qdbusconnectioninterface.h>
+#include <qdbusextratypes.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qdbusservicewatcher.h>
+#include <qlogging.h>
+
+namespace qs::network {
+
+namespace {
+Q_LOGGING_CATEGORY(logNetworkDevice, "quickshell.network.device", QtWarningMsg);
+} // namespace
+
+NetworkDevice::NetworkDevice(QObject* parent): QObject(parent) {};
+
+void NetworkDevice::setName(const QString& name) {
+	if (name == this->mName) return;
+	this->mName = name;
+	emit this->nameChanged();
+}
+
+void NetworkDevice::setAddress(const QString& address) {
+	if (address == this->mAddress) return;
+	this->mAddress = address;
+	emit this->addressChanged();
+}
+
+void NetworkDevice::setState(NetworkConnectionState::Enum state) {
+	if (state == this->mState) return;
+	this->mState = state;
+	emit this->stateChanged();
+}
+
+void NetworkDevice::setNmState(NMDeviceState::Enum nmState) {
+	if (nmState == this->mNmState) return;
+	this->mNmState = nmState;
+	emit this->nmStateChanged();
+}
+
+void NetworkDevice::disconnect() {
+	if (this->mState == NetworkConnectionState::Disconnected) {
+		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
+		return;
+	}
+	if (this->mState == NetworkConnectionState::Disconnecting) {
+		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
+		return;
+	}
+	qCDebug(logNetworkDevice) << "Disconnecting from device" << this;
+	this->requestDisconnect();
+}
+
+QString NetworkConnectionState::toString(NetworkConnectionState::Enum state) {
+	switch (state) {
+	case Unknown: return "Unknown";
+	case Connecting: return "Connecting";
+	case Connected: return "Connected";
+	case Disconnecting: return "Disconnecting";
+	case Disconnected: return "Disconnected";
+	}
+	return {};
+}
+
+} // namespace qs::network

src/network/device.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qdbusextratypes.h>
+#include <qdbusservicewatcher.h>
+#include <qhash.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "nm/enums.hpp"
+
+namespace qs::network {
+
+///! Connection state.
+class NetworkConnectionState: 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(NetworkConnectionState::Enum state);
+};
+
+///! A Network device.
+class NetworkDevice: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("Devices can only be acquired through Network");
+
+	/// The name of the device's interface.
+	Q_PROPERTY(QString name READ name NOTIFY nameChanged);
+	/// The hardware address of the device's interface in the XX:XX:XX:XX:XX:XX format.
+	Q_PROPERTY(QString address READ address NOTIFY addressChanged);
+	/// Connection state of the device.
+	Q_PROPERTY(NetworkConnectionState::Enum state READ state NOTIFY stateChanged);
+	/// A more specific device state when the backend is NetworkManager.
+	Q_PROPERTY(NMDeviceState::Enum nmState READ nmState NOTIFY nmStateChanged);
+
+signals:
+	void nameChanged();
+	void addressChanged();
+	void stateChanged();
+	void nmStateChanged();
+	void requestDisconnect();
+
+public slots:
+	void setName(const QString& name);
+	void setAddress(const QString& address);
+	void setState(NetworkConnectionState::Enum state);
+	void setNmState(NMDeviceState::Enum state);
+
+public:
+	explicit NetworkDevice(QObject* parent = nullptr);
+
+	[[nodiscard]] QString name() const { return this->mName; };
+	[[nodiscard]] QString address() const { return this->mAddress; };
+	[[nodiscard]] NetworkConnectionState::Enum state() const { return this->mState; };
+	[[nodiscard]] NMDeviceState::Enum nmState() const { return this->mNmState; };
+
+	/// Disconnects the device and prevents it from automatically activating further connections.
+	Q_INVOKABLE void disconnect();
+
+private:
+	QString mName;
+	QString mAddress;
+	NetworkConnectionState::Enum mState = NetworkConnectionState::Unknown;
+	NMDeviceState::Enum mNmState = NMDeviceState::Unknown;
+};
+
+} // namespace qs::network