network: add network integration with NetworkManager backend

CMakeLists.txt

@@ -71,6 +71,7 @@ boption(SERVICE_GREETD "Greetd" ON)
 boption(SERVICE_UPOWER "UPower" ON)
 boption(SERVICE_NOTIFICATIONS "Notifications" ON)
 boption(BLUETOOTH "Bluetooth" ON)
+boption(NETWORK "Network" ON)
 
 include(cmake/install-qml-module.cmake)
 include(cmake/util.cmake)
@@ -117,7 +118,7 @@ if (WAYLAND)
 	list(APPEND QT_FPDEPS WaylandClient)
 endif()
 
-if (SERVICE_STATUS_NOTIFIER OR SERVICE_MPRIS OR SERVICE_UPOWER OR SERVICE_NOTIFICATIONS OR BLUETOOTH)
+if (SERVICE_STATUS_NOTIFIER OR SERVICE_MPRIS OR SERVICE_UPOWER OR SERVICE_NOTIFICATIONS OR BLUETOOTH OR NETWORK)
 	set(DBUS ON)
 endif()
 

src/CMakeLists.txt

@@ -33,3 +33,7 @@ add_subdirectory(services)
 if (BLUETOOTH)
 	add_subdirectory(bluetooth)
 endif()
+
+if (NETWORK)
+	add_subdirectory(network)
+endif()

src/network/CMakeLists.txt

@@ -0,0 +1,96 @@
+# NetworkManager DBus
+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
+	nm/org.freedesktop.NetworkManager.xml
+	nm/dbus_nm_backend
+)
+
+set_source_files_properties(nm/org.freedesktop.NetworkManager.Device.xml PROPERTIES
+	CLASSNAME DBusNMDeviceProxy
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(NM_DBUS_INTERFACES
+	nm/org.freedesktop.NetworkManager.Device.xml
+	nm/dbus_nm_device
+)
+
+set_source_files_properties(nm/org.freedesktop.NetworkManager.Device.Wireless.xml PROPERTIES
+	CLASSNAME DBusNMWirelessProxy
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(NM_DBUS_INTERFACES
+	nm/org.freedesktop.NetworkManager.Device.Wireless.xml
+	nm/dbus_nm_wireless
+)
+
+set_source_files_properties(nm/org.freedesktop.NetworkManager.AccessPoint.xml PROPERTIES
+	CLASSNAME DBusNMAccessPointProxy
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(NM_DBUS_INTERFACES
+	nm/org.freedesktop.NetworkManager.AccessPoint.xml
+	nm/dbus_nm_accesspoint
+)
+
+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
+)
+
+qt_add_dbus_interface(NM_DBUS_INTERFACES
+	nm/org.freedesktop.NetworkManager.Settings.Connection.xml
+	nm/dbus_nm_connection_settings
+)
+
+set_source_files_properties(nm/org.freedesktop.NetworkManager.Connection.Active.xml PROPERTIES
+	CLASSNAME DBusNMActiveConnectionProxy
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(NM_DBUS_INTERFACES
+	nm/org.freedesktop.NetworkManager.Connection.Active.xml
+	nm/dbus_nm_active_connection
+)
+
+qt_add_library(quickshell-network STATIC
+	network.cpp
+	device.cpp
+	wifi.cpp
+	nm/backend.cpp
+	nm/device.cpp
+	nm/connection.cpp
+	nm/accesspoint.cpp
+	nm/wireless.cpp
+	nm/utils.cpp
+	nm/enums.hpp
+	${NM_DBUS_INTERFACES}
+)
+
+# dbus headers
+target_include_directories(quickshell-network PRIVATE 
+	${CMAKE_CURRENT_BINARY_DIR}
+)
+
+qt_add_qml_module(quickshell-network
+	URI Quickshell.Network
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-network Quickshell)
+install_qml_module(quickshell-network)
+
+target_link_libraries(quickshell-network PRIVATE Qt::Qml Qt::DBus)
+qs_add_link_dependencies(quickshell-network quickshell-dbus)
+target_link_libraries(quickshell PRIVATE quickshell-networkplugin)
+
+qs_module_pch(quickshell-network SET dbus)

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

src/network/network.cpp

@@ -0,0 +1,40 @@
+#include "network.hpp"
+
+#include <qdbusconnection.h>
+#include <qdbusconnectioninterface.h>
+#include <qdbusextratypes.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qdbusservicewatcher.h>
+#include <qlogging.h>
+
+#include "nm/backend.hpp"
+
+namespace qs::network {
+
+namespace {
+Q_LOGGING_CATEGORY(logNetwork, "quickshell.network", QtWarningMsg);
+} // namespace
+
+Network::Network(QObject* parent): QObject(parent), mWifi(new Wifi(this)) {
+	// NetworkManager
+	auto* nm = new NetworkManager(this);
+	if (nm->isAvailable()) {
+		// clang-format off
+		QObject::connect(nm, &NetworkManager::wifiDeviceAdded, this->wifi(), &Wifi::onDeviceAdded);
+		QObject::connect(nm, &NetworkManager::wifiDeviceRemoved, this->wifi(), &Wifi::onDeviceRemoved);
+		QObject::connect(nm, &NetworkManager::wifiEnabledChanged, this->wifi(), &Wifi::onEnabledSet);
+		QObject::connect(nm, &NetworkManager::wifiHardwareEnabledChanged, this->wifi(), &Wifi::onHardwareEnabledSet);
+		QObject::connect(this->wifi(), &Wifi::requestSetEnabled, nm, &NetworkManager::setWifiEnabled);
+		// clang-format on
+		this->mBackend = nm;
+		this->mBackendType = NetworkBackendType::NetworkManager;
+		return;
+	} else {
+		delete nm;
+	}
+
+	qCCritical(logNetwork) << "Network will not work. Could not find an available backend.";
+}
+
+} // namespace qs::network

src/network/network.hpp

@@ -0,0 +1,68 @@
+#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 "wifi.hpp"
+
+namespace qs::network {
+
+///! The backend supplying the Network service.
+class NetworkBackendType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// There is no available Network backend.
+		None = 0,
+		/// The backend is NetworkManager.
+		NetworkManager = 1,
+	};
+	Q_ENUM(Enum);
+};
+
+class NetworkBackend: public QObject {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] virtual bool isAvailable() const = 0;
+
+protected:
+	explicit NetworkBackend(QObject* parent = nullptr): QObject(parent) {};
+};
+
+///! The Network service.
+/// An interface to a network backend (currently only NetworkManager),
+/// which can be used to view, configure, and connect to various networks.
+class Network: public QObject {
+	Q_OBJECT;
+	QML_NAMED_ELEMENT(Network);
+	QML_SINGLETON;
+
+	/// The wifi device service.
+	Q_PROPERTY(Wifi* wifi READ wifi CONSTANT);
+	/// The backend being used to power the Network service.
+	Q_PROPERTY(NetworkBackendType::Enum backend READ backend);
+
+public:
+	explicit Network(QObject* parent = nullptr);
+
+	[[nodiscard]] Wifi* wifi() { return this->mWifi; };
+	[[nodiscard]] NetworkBackendType::Enum backend() { return this->mBackendType; };
+
+private:
+	Wifi* mWifi;
+	NetworkBackend* mBackend = nullptr;
+	NetworkBackendType::Enum mBackendType = NetworkBackendType::None;
+};
+
+} // namespace qs::network