feat: AccessPoints -> WifiNetworks

Access point objects shouldn't be provided to the user. Instead, we
should expose WifiNetworks which represent a set of APs with the same
SSID. A WifiNetwork signal represents the maximum signal of its APs.

Author: cpwrs

src/network/api.cpp

@@ -77,9 +77,9 @@ void NetworkDevice::disconnect() {
 
 // WirelessNetworkDevice
 
-WirelessNetworkDevice::WirelessNetworkDevice(QObject* parent): NetworkDevice(parent) {};
+NetworkWifiDevice::NetworkWifiDevice(QObject* parent): NetworkDevice(parent) {};
 
-void WirelessNetworkDevice::scanComplete(qint64 lastScan) {
+void NetworkWifiDevice::scanComplete(qint64 lastScan) {
 	this->bLastScan = lastScan;
 	emit this->lastScanChanged();
 
@@ -89,7 +89,7 @@ void WirelessNetworkDevice::scanComplete(qint64 lastScan) {
 	}
 }
 
-void WirelessNetworkDevice::scan() {
+void NetworkWifiDevice::scan() {
 	if (this->bScanning) {
 		qCCritical(logNetworkDevice) << "Wireless device" << this << "is already scanning";
 		return;
@@ -100,26 +100,24 @@ void WirelessNetworkDevice::scan() {
 	signalScan();
 }
 
-void WirelessNetworkDevice::addAccessPoint(NetworkAccessPoint* ap) {
-	mAccessPoints.insertObject(ap);
-}
+void NetworkWifiDevice::addNetwork(NetworkWifiNetwork* network) { mNetworks.insertObject(network); }
 
-void WirelessNetworkDevice::removeAccessPoint(NetworkAccessPoint* ap) {
-	mAccessPoints.removeObject(ap);
+void NetworkWifiDevice::removeNetwork(NetworkWifiNetwork* network) {
+	mNetworks.removeObject(network);
 }
 
 // NetworkAccessPoint
 
-NetworkAccessPoint::NetworkAccessPoint(QObject* parent): QObject(parent) {};
+NetworkWifiNetwork::NetworkWifiNetwork(QObject* parent): QObject(parent) {};
 
-void NetworkAccessPoint::setSsid(const QString& ssid) {
+void NetworkWifiNetwork::setSsid(const QString& ssid) {
 	if (this->bSsid != ssid) {
 		this->bSsid = ssid;
 		emit ssidChanged();
 	}
 }
 
-void NetworkAccessPoint::setSignal(quint8 signal) {
+void NetworkWifiNetwork::setSignal(quint8 signal) {
 	if (this->bSignal != signal) {
 		this->bSignal = signal;
 		emit signalChanged();

src/network/api.hpp

@@ -14,15 +14,15 @@
 
 namespace qs::network {
 
-///! A tracked access point on the network
-class NetworkAccessPoint: public QObject {
+///! A wifi network available to a wifi device
+class NetworkWifiNetwork: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
-	QML_UNCREATABLE("WirelessNetwork can only be acquired through Network");
+	QML_UNCREATABLE("Wifi netorks can only be acquired through Network");
 	// clang-format off
-	/// The service set identifier of the access point.
+	/// The service set identifier of the wifi network
 	Q_PROPERTY(QString ssid READ default NOTIFY ssidChanged BINDABLE bindableSsid);
-	// The current signal quality of the access point, in percent.
+	// The current signal quality of the best access point on the network, in percent.
 	Q_PROPERTY(quint8 signal READ default NOTIFY signalChanged BINDABLE bindableSignal);
 	//clang-format on
 
@@ -35,14 +35,14 @@ public slots:
 	void setSignal(quint8 signal);
 
 public:
-	explicit NetworkAccessPoint(QObject* parent = nullptr);
+	explicit NetworkWifiNetwork(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);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkWifiNetwork, QString, bSsid, &NetworkWifiNetwork::ssidChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkWifiNetwork, quint8, bSignal, &NetworkWifiNetwork::signalChanged);
 };
 
 ///! Type of network device.
@@ -139,17 +139,17 @@ public slots:
 };
 
 ///! Wireless variant of a tracked network device.
-class WirelessNetworkDevice: public NetworkDevice {
+class NetworkWifiDevice: public NetworkDevice {
 	Q_OBJECT;
 
 	// clang-format off
 	/// The timestamp (in CLOCK_BOOTTIME milliseconds) for the last finished network scan.
 	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>*)
+	/// A list of all available wifi networks
+	Q_PROPERTY(UntypedObjectModel* networks READ networks CONSTANT);
+	QSDOC_TYPE_OVERRIDE(ObjectModel<NetworkWifiNetwork>*)
 	//clang-format on
 
 signals:
@@ -160,11 +160,11 @@ class WirelessNetworkDevice: public NetworkDevice {
 
 public slots:
 	void scanComplete(qint64 lastScan);
-	void addAccessPoint(NetworkAccessPoint* ap);
-	void removeAccessPoint(NetworkAccessPoint* ap);
+	void addNetwork(NetworkWifiNetwork* network);
+	void removeNetwork(NetworkWifiNetwork* network);
 
 public:
-	explicit WirelessNetworkDevice(QObject* parent = nullptr);
+	explicit NetworkWifiDevice(QObject* parent = nullptr);
 	[[nodiscard]] NetworkDeviceType::Enum type() const override { return NetworkDeviceType::Wireless; };
 
 	/// Request the wireless device to scan for available WiFi networks.
@@ -173,12 +173,12 @@ public slots:
 	[[nodiscard]] QBindable<bool> bindableScanning() { return &this->bScanning; };
 	[[nodiscard]] QBindable<qint64> bindableLastScan() { return &this->bLastScan; };
 
-	UntypedObjectModel* accessPoints() { return &this->mAccessPoints; };
+	UntypedObjectModel* networks() { return &this->mNetworks; };
 
 private:
-	ObjectModel<NetworkAccessPoint> mAccessPoints{this};
-	Q_OBJECT_BINDABLE_PROPERTY(WirelessNetworkDevice, bool, bScanning, &WirelessNetworkDevice::scanningChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(WirelessNetworkDevice, qint64, bLastScan, &WirelessNetworkDevice::lastScanChanged);
+	ObjectModel<NetworkWifiNetwork> mNetworks {this};
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkWifiDevice, bool, bScanning, &NetworkWifiDevice::scanningChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkWifiDevice, qint64, bLastScan, &NetworkWifiDevice::lastScanChanged);
 };
 
 // -- Network --

src/network/nm_adapters.cpp

@@ -34,7 +34,7 @@ void NMDeviceAdapter::init(const QString& path) {
 	);
 
 	if (!this->proxy->isValid()) {
-		qCWarning(logNetworkManager) << "Cannot create NMDeviceAdapter for" << path;
+		qCWarning(logNetworkManager) << "Cannot create dbus proxy for" << path;
 		return;
 	}
 
@@ -72,7 +72,7 @@ void NMWirelessAdapter::init(const QString& path) {
 	);
 
 	if (!this->proxy->isValid()) {
-		qCWarning(logNetworkManager) << "Cannot create NMWirelessAdapter for" << path;
+		qCWarning(logNetworkManager) << "Cannot create dbus proxy for" << path;
 		return;
 	}
 
@@ -101,16 +101,16 @@ void NMWirelessAdapter::onAccessPointAdded(const QDBusObjectPath& path) {
 }
 
 void NMWirelessAdapter::onAccessPointRemoved(const QDBusObjectPath& path) {
-	auto iter = this->mAPHash.find(path.path());
-	if (iter == this->mAPHash.end()) {
-		qCWarning(logNetworkManager) << "NMWirelessAdapter sent removal signal for" << path.path()
-		                             << "which is not registered.";
-	} else {
-		auto* ap = iter.value();
-		this->mAPHash.erase(iter);
-		emit accessPointRemoved(ap);
-		qCDebug(logNetworkManager) << "Access point" << path.path() << "removed.";
+	auto* ap = mPathToApHash.take(path.path());
+
+	if (!ap) {
+		qCDebug(logNetworkManager) << "NetworkManager backend sent removal signal for" << path.path()
+		                           << "which is not registered.";
+		return;
 	}
+
+	removeApFromNetwork(ap);
+	delete ap;
 }
 
 void NMWirelessAdapter::registerAccessPoints() {
@@ -135,35 +135,80 @@ void NMWirelessAdapter::registerAccessPoints() {
 }
 
 void NMWirelessAdapter::registerAccessPoint(const QString& path) {
-	if (this->mAPHash.contains(path)) {
+	if (this->mPathToApHash.contains(path)) {
 		qCDebug(logNetworkManager) << "Skipping duplicate registration of access point" << path;
 		return;
 	}
 
-	// Create an access point adapter
-	auto* apAdapter = new NMAccessPointAdapter();
-	apAdapter->init(path);
+	auto* ap = new NMAccessPointAdapter(this);
+	ap->init(path);
 
-	if (!apAdapter->isValid()) {
-		qCWarning(logNetworkManager) << "Cannot create NMAccessPointAdapter for" << path;
-		delete apAdapter;
+	if (!ap->isValid()) {
+		qCWarning(logNetworkManager) << "Cannot create access point for" << path;
+		delete ap;
 		return;
 	}
-	auto* ap = new NetworkAccessPoint(this);
-	apAdapter->setParent(ap);
 
-	// NMAccessPointAdapter signal -> NetworkAccessPoint slot
-	QObject::connect(apAdapter, &NMAccessPointAdapter::ssidChanged, ap, &NetworkAccessPoint::setSsid);
+	this->mPathToApHash.insert(path, ap);
+	qCDebug(logNetworkManager) << "Registered access point" << path;
+
 	QObject::connect(
-	    apAdapter,
-	    &NMAccessPointAdapter::signalChanged,
 	    ap,
-	    &NetworkAccessPoint::setSignal
+	    &NMAccessPointAdapter::ssidChanged,
+	    this,
+	    [this, ap](const QByteArray& ssid) {
+		    if (ssid.isEmpty()) {
+			    this->removeApFromNetwork(ap);
+		    } else {
+			    this->addApToNetwork(ap, ssid);
+		    }
+	    }
 	);
+}
 
-	this->mAPHash.insert(path, ap);
-	emit accessPointAdded(ap);
-	qCDebug(logNetworkManager) << "Registered access point" << path;
+void NMWirelessAdapter::addApToNetwork(NMAccessPointAdapter* ap, const QByteArray& ssid) {
+	// Remove AP from old network
+	removeApFromNetwork(ap);
+
+	auto* group = mSsidToApGroupHash.value(ssid);
+	if (!group) {
+		// Create a new AP group and wifi network
+		group = new NMAccessPointGroup(ssid, this);
+		auto* network = new NetworkWifiNetwork(this);
+		network->setSsid(ssid);
+
+		// NMAccessPointGroup signal -> NetworkWifiNetwork slot
+		QObject::connect(
+		    group,
+		    &NMAccessPointGroup::maxSignalChanged,
+		    network,
+		    &NetworkWifiNetwork::setSignal
+		);
+
+		this->mSsidToApGroupHash.insert(ssid, group);
+		this->mSsidToNetworkHash.insert(ssid, network);
+		emit this->wifiNetworkAdded(network);
+		qCDebug(logNetworkManager) << "Registered wifi network" << ssid;
+	}
+
+	group->addAccessPoint(ap);
+	this->mPathToSsidHash.insert(ap->path(), ssid);
+}
+
+void NMWirelessAdapter::removeApFromNetwork(NMAccessPointAdapter* ap) {
+	QByteArray ssid = mPathToSsidHash.take(ap->path());
+	if (ssid.isEmpty()) return; // AP wasn't in any network
+
+	auto* group = mSsidToApGroupHash.value(ssid);
+	group->removeAccessPoint(ap);
+	if (group->isEmpty()) {
+		mSsidToApGroupHash.remove(ssid);
+		auto* network = mSsidToNetworkHash.take(ssid);
+		emit wifiNetworkRemoved(network);
+		delete network;
+		delete group;
+		qCDebug(logNetworkManager) << "Deleted wifi network" << ssid;
+	}
 }
 
 void NMWirelessAdapter::scan() { this->proxy->RequestScan({}); }
@@ -176,10 +221,6 @@ QString NMWirelessAdapter::path() const { return this->proxy ? this->proxy->path
 
 // Access Point
 
-namespace {
-Q_LOGGING_CATEGORY(logNMAccessPoint, "quickshell.network.networkmanager.accesspoint", QtWarningMsg);
-}
-
 NMAccessPointAdapter::NMAccessPointAdapter(QObject* parent): QObject(parent) {}
 
 void NMAccessPointAdapter::init(const QString& path) {
@@ -191,7 +232,7 @@ void NMAccessPointAdapter::init(const QString& path) {
 	);
 
 	if (!this->proxy->isValid()) {
-		qCWarning(logNMAccessPoint) << "Cannot create NMWirelessAdapter for" << path;
+		qCWarning(logNetworkManager) << "Cannot create access point proxy for" << path;
 		return;
 	}
 
@@ -205,6 +246,47 @@ QString NMAccessPointAdapter::address() const {
 }
 QString NMAccessPointAdapter::path() const { return this->proxy ? this->proxy->path() : QString(); }
 
+// Access Point Group
+
+NMAccessPointGroup::NMAccessPointGroup(const QByteArray& ssid, QObject* parent)
+    : QObject(parent)
+    , mSsid(ssid) {}
+
+void NMAccessPointGroup::updateMaxSignal() {
+	quint8 max = 0;
+	for (auto* ap: mAccessPoints) {
+		max = qMax(max, ap->getSignal());
+	}
+	if (this->bMaxSignal != max) {
+		this->bMaxSignal = max;
+	}
+}
+
+void NMAccessPointGroup::addAccessPoint(NMAccessPointAdapter* ap) {
+	if (this->mAccessPoints.contains(ap)) return;
+
+	this->mAccessPoints.append(ap);
+	QObject::connect(
+	    ap,
+	    &NMAccessPointAdapter::signalChanged,
+	    this,
+	    &NMAccessPointGroup::updateMaxSignal
+	);
+	this->updateMaxSignal();
+}
+
+void NMAccessPointGroup::removeAccessPoint(NMAccessPointAdapter* ap) {
+	if (mAccessPoints.removeOne(ap)) {
+		QObject::disconnect(
+		    ap,
+		    &NMAccessPointAdapter::signalChanged,
+		    this,
+		    &NMAccessPointGroup::updateMaxSignal
+		);
+		this->updateMaxSignal();
+	}
+}
+
 } // namespace qs::network
 
 namespace qs::dbus {