feat: accessPoints

Author: cpwrs

src/network/CMakeLists.txt

@@ -29,6 +29,16 @@ qt_add_dbus_interface(NM_DBUS_INTERFACES
 	dbus_nm_wireless
 )
 
+set_source_files_properties(org.freedesktop.NetworkManager.AccessPoint.xml PROPERTIES
+	CLASSNAME DBusNMAccessPointProxy
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(NM_DBUS_INTERFACES
+	org.freedesktop.NetworkManager.AccessPoint.xml
+	dbus_nm_accesspoint
+)
+
 qt_add_library(quickshell-network STATIC
 	api.cpp
 	nm_backend.cpp

src/network/api.cpp

@@ -13,12 +13,13 @@
 namespace qs::network {
 
 namespace {
-Q_LOGGING_CATEGORY(logNetworkNetworkDevice, "quickshell.network.device", QtWarningMsg);
+Q_LOGGING_CATEGORY(logNetworkDevice, "quickshell.network.device", QtWarningMsg);
 Q_LOGGING_CATEGORY(logNetwork, "quickshell.network", QtWarningMsg);
 } // namespace
 
+// NetworkDevice
+
 NetworkDevice::NetworkDevice(QObject* parent): QObject(parent) {};
-WirelessNetworkDevice::WirelessNetworkDevice(QObject* parent): NetworkDevice(parent) {};
 
 QString NetworkDeviceState::toString(NetworkDeviceState::Enum state) {
 	switch (state) {
@@ -60,20 +61,24 @@ void NetworkDevice::setState(NetworkDeviceState::Enum state) {
 
 void NetworkDevice::disconnect() {
 	if (this->bState == NetworkDeviceState::Disconnected) {
-		qCCritical(logNetworkNetworkDevice) << "NetworkDevice" << this << "is already disconnected";
+		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
 		return;
 	}
 
 	if (this->bState == NetworkDeviceState::Disconnecting) {
-		qCCritical(logNetworkNetworkDevice) << "NetworkDevice" << this << "is already disconnecting";
+		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
 		return;
 	}
 
-	qCDebug(logNetworkNetworkDevice) << "Disconnecting from device" << this;
+	qCDebug(logNetworkDevice) << "Disconnecting from device" << this;
 
 	signalDisconnect();
 }
 
+// WirelessNetworkDevice
+
+WirelessNetworkDevice::WirelessNetworkDevice(QObject* parent): NetworkDevice(parent) {};
+
 void WirelessNetworkDevice::scanComplete(qint64 lastScan) {
 	this->bLastScan = lastScan;
 	emit this->lastScanChanged();
@@ -86,28 +91,62 @@ void WirelessNetworkDevice::scanComplete(qint64 lastScan) {
 
 void WirelessNetworkDevice::scan() {
 	if (this->bScanning) {
-		qCCritical(logNetworkNetworkDevice) << "NetworkDevice" << this << "is already scanning";
+		qCCritical(logNetworkDevice) << "Wireless device" << this << "is already scanning";
 		return;
 	}
 
-	qCDebug(logNetworkNetworkDevice) << "Requesting scan on wireless device" << this;
+	qCDebug(logNetworkDevice) << "Requesting scan on wireless device" << this;
 	this->bScanning = true;
 	signalScan();
 }
 
+void WirelessNetworkDevice::addAccessPoint(NetworkAccessPoint* ap) {
+	mAccessPoints.insertObject(ap);
+}
+
+void WirelessNetworkDevice::removeAccessPoint(NetworkAccessPoint* ap) {
+	mAccessPoints.removeObject(ap);
+}
+
+// NetworkAccessPoint
+
+NetworkAccessPoint::NetworkAccessPoint(QObject* parent): QObject(parent) {};
+
+void NetworkAccessPoint::setSsid(const QString& ssid) {
+	if (this->bSsid != ssid) {
+		this->bSsid = ssid;
+		emit ssidChanged();
+	}
+}
+
+void NetworkAccessPoint::setSignal(quint8 signal) {
+	if (this->bSignal != signal) {
+		this->bSignal = signal;
+		emit signalChanged();
+	}
+}
+
+// Network
+
 Network::Network(QObject* parent): QObject(parent) {
 	// Try each backend
 
 	// NetworkManager
 	auto* nm = new NetworkManager();
 	if (nm->isAvailable()) {
+		QObject::connect(nm, &NetworkManager::deviceAdded, this, &Network::addDevice);
+		QObject::connect(nm, &NetworkManager::deviceRemoved, this, &Network::removeDevice);
 		this->backend = nm;
 		return;
 	}
 
 	// None found
 	this->backend = nullptr;
-	qCDebug(logNetwork) << "Network will not work. Could not find an available backend.";
+	qCCritical(logNetwork) << "Network will not work. Could not find an available backend.";
 }
 
+void Network::addDevice(NetworkDevice* device) { this->mDevices.insertObject(device); }
+
+void Network::removeDevice(NetworkDevice* device) { this->mDevices.removeObject(device); }
+
 } // namespace qs::network

src/network/api.hpp

@@ -14,6 +14,36 @@
 
 namespace qs::network {
 
+///! A tracked access point on the network
+class NetworkAccessPoint: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("WirelessNetwork can only be acquired through Network");
+	// clang-format off
+	/// The service set identifier of the access point.
+	Q_PROPERTY(QString ssid READ default NOTIFY ssidChanged BINDABLE bindableSsid);
+	// The current signal quality of the access point, in percent.
+	Q_PROPERTY(quint8 signal READ default NOTIFY signalChanged BINDABLE bindableSignal);
+	//clang-format on
+
+signals:
+	void ssidChanged();
+	void signalChanged();
+
+public slots:
+	void setSsid(const QString& ssid);
+	void setSignal(quint8 signal);
+
+public:
+	explicit NetworkAccessPoint(QObject* parent = nullptr);
+
+	[[nodiscard]] QBindable<QString> bindableSsid() const { return &this->bSsid; };
+	[[nodiscard]] QBindable<quint8> bindableSignal() const { return &this->bSignal; };
+
+private:
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkAccessPoint, QString, bSsid, &NetworkAccessPoint::ssidChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkAccessPoint, quint8, bSignal, &NetworkAccessPoint::signalChanged);
+};
 
 ///! Type of network device.
 class NetworkDeviceType: public QObject {
@@ -79,11 +109,9 @@ class NetworkDevice: public QObject {
 	void addressChanged();
 	void stateChanged();
 
-	// For backend slots
 	void signalDisconnect();
 
 public slots:
-	// For backend signals
 	void setName(const QString& name);
 	void setAddress(const QString& address);
 	void setState(NetworkDeviceState::Enum state);
@@ -102,7 +130,12 @@ public slots:
 private:
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bName, &NetworkDevice::nameChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bAddress, &NetworkDevice::addressChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, NetworkDeviceState::Enum, bState, &NetworkDevice::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    NetworkDevice,
+	    NetworkDeviceState::Enum,
+	    bState,
+	    &NetworkDevice::stateChanged
+	);
 };
 
 ///! Wireless variant of a tracked network device.
@@ -114,18 +147,21 @@ class WirelessNetworkDevice: public NetworkDevice {
 	Q_PROPERTY(qint64 lastScan READ default NOTIFY lastScanChanged BINDABLE bindableLastScan);
 	/// True if the wireless device is currently scanning for available wifi networks.
 	Q_PROPERTY(bool scanning READ default NOTIFY scanningChanged BINDABLE bindableScanning);
+	/// A list of all available access points
+	Q_PROPERTY(UntypedObjectModel* accessPoints READ accessPoints CONSTANT); 
+	QSDOC_TYPE_OVERRIDE(ObjectModel<NetworkAccessPoint>*)
 	//clang-format on
 
 signals:
 	void signalScan();
 
-	// Frontend-facing signals
 	void lastScanChanged();
 	void scanningChanged();
 
 public slots:
-	// For backend signals
 	void scanComplete(qint64 lastScan);
+	void addAccessPoint(NetworkAccessPoint* ap);
+	void removeAccessPoint(NetworkAccessPoint* ap);
 
 public:
 	explicit WirelessNetworkDevice(QObject* parent = nullptr);
@@ -137,11 +173,12 @@ public slots:
 	[[nodiscard]] QBindable<bool> bindableScanning() { return &this->bScanning; };
 	[[nodiscard]] QBindable<qint64> bindableLastScan() { return &this->bLastScan; };
 
+	UntypedObjectModel* accessPoints() { return &this->mAccessPoints; };
+
 private:
-	// clang-format off
+	ObjectModel<NetworkAccessPoint> mAccessPoints{this};
 	Q_OBJECT_BINDABLE_PROPERTY(WirelessNetworkDevice, bool, bScanning, &WirelessNetworkDevice::scanningChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(WirelessNetworkDevice, qint64, bLastScan, &WirelessNetworkDevice::lastScanChanged);
-	// clang-format on
 };
 
 // -- Network --
@@ -150,29 +187,36 @@ class NetworkBackend: public QObject {
 
 public:
 	[[nodiscard]] virtual bool isAvailable() const = 0;
-	virtual UntypedObjectModel* devices() = 0;
-	virtual WirelessNetworkDevice* defaultWifiDevice() = 0;
 
 protected:
 	explicit NetworkBackend(QObject* parent = nullptr): QObject(parent) {};
 };
 
+///! Network manager
+/// Provides access to network devices.
 class Network: public QObject {
 	Q_OBJECT;
 	QML_NAMED_ELEMENT(Network);
 	QML_SINGLETON;
 
-	Q_PROPERTY(WirelessNetworkDevice* defaultWifiNetworkDevice READ defaultWifiNetworkDevice CONSTANT);
+	// clang-format off
+	/// The default wifi device. Usually there is only one. This defaults to the first wifi device registered.
+	// Q_PROPERTY(WirelessNetworkDevice* defaultWifiDevice READ defaultWifiDevice CONSTANT);
+	/// A list of all network devices.
 	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::network::NetworkDevice>*);
+	// clang-format on
+
+public slots:
+	void addDevice(NetworkDevice* device);
+	void removeDevice(NetworkDevice* device);
 
 public:
 	explicit Network(QObject* parent = nullptr);
-	[[nodiscard]] UntypedObjectModel* devices() { return backend ? backend->devices() : nullptr; };
-	[[nodiscard]] WirelessNetworkDevice* defaultWifiNetworkDevice() {
-		return backend ? backend->defaultWifiDevice() : nullptr;
-	};
+	[[nodiscard]] UntypedObjectModel* devices() { return backend ? &this->mDevices : nullptr; };
 
 private:
+	ObjectModel<NetworkDevice> mDevices {this};
 	class NetworkBackend* backend = nullptr;
 };