network: add WifiScanner

- Add WifiScanner to replace requestScan in API
- Implement NM scanner that avoids rate limit
- Add conditional visibility to networks based on scanner state
- Add gates to backend-specific props in the manual test

Author: cpwrs

src/network/nm/backend.cpp

@@ -139,6 +139,7 @@ void NetworkManager::registerWifiDevice(const QString& path) {
 	}
 
 	auto* device = new WifiDevice(this);
+	auto* scanner = device->wifiScanner();
 	wireless->setParent(device);
 	this->mDeviceHash.insert(path, device);
 
@@ -154,13 +155,12 @@ void NetworkManager::registerWifiDevice(const QString& path) {
 		case 110 ... 120: return DeviceConnectionState::Disconnecting;
 		}
 	});
-	device->bindableScanning().setBinding([wireless]() { return wireless->scanning(); });
 	// clang-format off
 	QObject::connect(wireless, &NMWirelessDevice::addAndActivateConnection, this, &NetworkManager::addAndActivateConnection);
 	QObject::connect(wireless, &NMWirelessDevice::activateConnection, this, &NetworkManager::activateConnection);
-	QObject::connect(wireless, &NMWirelessDevice::wifiNetworkAdded, device, &WifiDevice::networkAdded);
-	QObject::connect(wireless, &NMWirelessDevice::wifiNetworkRemoved, device, &WifiDevice::networkRemoved);
-	QObject::connect(device, &WifiDevice::requestScan, wireless, &NMWirelessDevice::scan);
+	QObject::connect(wireless, &NMWirelessDevice::networkAdded, device, &WifiDevice::networkAdded);
+	QObject::connect(wireless, &NMWirelessDevice::networkRemoved, device, &WifiDevice::networkRemoved);
+	QObject::connect(scanner, &WifiScanner::requestEnabled, wireless, &NMWirelessDevice::handleScanner);
 	QObject::connect(device, &WifiDevice::requestDisconnect, wireless, &NMWirelessDevice::disconnect);
 	// clang-format on
 

src/network/nm/utils.cpp

@@ -1,9 +1,15 @@
 #include "utils.hpp"
 
+// We depend on non-std Linux extensions that ctime doesn't put in the global namespace
+// NOLINTNEXTLINE(modernize-deprecated-headers)
+#include <time.h>
+
 #include <qcontainerfwd.h>
+#include <qdatetime.h>
 #include <qdbusservicewatcher.h>
 #include <qobject.h>
 #include <qqmlintegration.h>
+#include <qtypes.h>
 
 #include "../wifi.hpp"
 #include "dbus_types.hpp"
@@ -218,4 +224,25 @@ WifiSecurityType::Enum findBestWirelessSecurity(
 	return WifiSecurityType::Unknown;
 }
 
+// NOLINTBEGIN
+QDateTime clockBootTimeToDateTime(qint64 clockBootTime) {
+	clockid_t clkId = CLOCK_BOOTTIME;
+	struct timespec tp {};
+
+	const QDateTime now = QDateTime::currentDateTime();
+	int r = clock_gettime(clkId, &tp);
+	if (r == -1 && errno == EINVAL) {
+		clkId = CLOCK_MONOTONIC;
+		r = clock_gettime(clkId, &tp);
+	}
+
+	// Convert to milliseconds
+	const qint64 nowInMs = tp.tv_sec * 1000 + tp.tv_nsec / 1000000;
+
+	// Return a QDateTime of the millisecond diff
+	const qint64 offset = clockBootTime - nowInMs;
+	return QDateTime::fromMSecsSinceEpoch(now.toMSecsSinceEpoch() + offset);
+}
+// NOLINTEND
+
 } // namespace qs::network

src/network/nm/utils.hpp

@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include <qcontainerfwd.h>
@@ -41,4 +40,6 @@ WifiSecurityType::Enum findBestWirelessSecurity(
     NM80211ApSecurityFlags::Enum apRsn
 );
 
+QDateTime clockBootTimeToDateTime(qint64 clockBootTime);
+
 } // namespace qs::network

src/network/nm/wireless.cpp

@@ -1,6 +1,7 @@
 #include "wireless.hpp"
 #include <utility>
 
+#include <qdatetime.h>
 #include <qdbusconnection.h>
 #include <qdbusextratypes.h>
 #include <qdbuspendingcall.h>
@@ -181,7 +182,9 @@ void NMWirelessNetwork::removeActiveConnection() {
 	}
 };
 
-NMWirelessDevice::NMWirelessDevice(const QString& path, QObject* parent): NMDevice(path, parent) {
+NMWirelessDevice::NMWirelessDevice(const QString& path, QObject* parent)
+    : NMDevice(path, parent)
+    , mScanTimer(this) {
 	this->wirelessProxy = new DBusNMWirelessProxy(
 	    "org.freedesktop.NetworkManager",
 	    path,
@@ -202,6 +205,9 @@ NMWirelessDevice::NMWirelessDevice(const QString& path, QObject* parent): NMDevi
 	    Qt::SingleShotConnection
 	);
 
+	QObject::connect(&this->mScanTimer, &QTimer::timeout, this, &NMWirelessDevice::onScanTimeout);
+	this->mScanTimer.setSingleShot(true);
+
 	this->wirelessProperties.setInterface(this->wirelessProxy);
 	this->wirelessProperties.updateAllViaGetAll();
 }
@@ -213,7 +219,6 @@ void NMWirelessDevice::initWireless() {
 	QObject::connect(this, &NMWirelessDevice::accessPointLoaded, this, &NMWirelessDevice::onAccessPointLoaded);
 	QObject::connect(this, &NMWirelessDevice::connectionLoaded, this, &NMWirelessDevice::onConnectionLoaded);
 	QObject::connect(this, &NMWirelessDevice::activeConnectionLoaded, this, &NMWirelessDevice::onActiveConnectionLoaded);
-	QObject::connect(this, &NMWirelessDevice::lastScanChanged, this, [this]() { this->bScanning = false; });
 	// clang-format on
 	this->registerAccessPoints();
 }
@@ -279,25 +284,47 @@ void NMWirelessDevice::registerAccessPoint(const QString& path) {
 	);
 }
 
+// Only make WifiNetworks visible to the frontend WifiDevice when
+// scanning is enabled or the network is connected or the network has known settings.
+void NMWirelessDevice::updateNetworkVisibility(WifiNetwork* net) {
+	const bool show = this->mScanning || net->connected() || net->known();
+	const bool visible = this->mVisibleNetworks.contains(net);
+
+	if (show && !visible) {
+		this->mVisibleNetworks.insert(net);
+		emit this->networkAdded(net);
+	} else if (!show && visible) {
+		this->mVisibleNetworks.remove(net);
+		emit this->networkRemoved(net);
+	}
+}
+
 NMWirelessNetwork* NMWirelessDevice::registerNetwork(const QString& ssid) {
 	auto* backend = new NMWirelessNetwork(ssid, this);
 	backend->bindableActiveApPath().setBinding([this]() { return this->activeApPath().path(); });
 	backend->bindableCapabilities().setBinding([this]() { return this->capabilities(); });
 
 	auto* frontend = new WifiNetwork(ssid, this);
-	frontend->bindableSignalStrength().setBinding([backend]() { return backend->signalStrength()/100.0; });
+	frontend->bindableSignalStrength().setBinding([backend]() {
+		return backend->signalStrength() / 100.0;
+	});
 	frontend->bindableConnected().setBinding([backend]() {
-		return backend->state() != NMConnectionState::Deactivated;
+		return backend->state() == NMConnectionState::Activated;
 	});
 	frontend->bindableKnown().setBinding([backend]() { return backend->known(); });
 	frontend->bindableNmReason().setBinding([backend]() { return backend->reason(); });
 	frontend->bindableSecurity().setBinding([backend]() { return backend->security(); });
 	QObject::connect(backend, &NMWirelessNetwork::disappeared, this, [this, frontend, backend]() {
 		QObject::disconnect(backend, nullptr, nullptr, nullptr);
-		emit this->wifiNetworkRemoved(frontend);
+		QObject::disconnect(frontend, nullptr, nullptr, nullptr);
 		this->mBackendNetworks.remove(backend->ssid());
-		delete backend;
+		this->mNetworks.remove(frontend->name());
+		if (this->mVisibleNetworks.contains(frontend)) {
+			this->mVisibleNetworks.remove(frontend);
+			emit this->networkRemoved(frontend);
+		}
 		delete frontend;
+		delete backend;
 	});
 	QObject::connect(frontend, &WifiNetwork::requestConnect, this, [this, backend]() {
 		if (backend->referenceConnection()) {
@@ -315,9 +342,16 @@ NMWirelessNetwork* NMWirelessDevice::registerNetwork(const QString& ssid) {
 			);
 		}
 	});
+	QObject::connect(frontend, &WifiNetwork::connectedChanged, this, [this, frontend]() {
+		updateNetworkVisibility(frontend);
+	});
+	QObject::connect(frontend, &WifiNetwork::knownChanged, this, [this, frontend]() {
+		updateNetworkVisibility(frontend);
+	});
 
 	this->mBackendNetworks.insert(ssid, backend);
-	emit this->wifiNetworkAdded(frontend);
+	this->mNetworks.insert(ssid, frontend);
+	this->updateNetworkVisibility(frontend);
 	return backend;
 }
 
@@ -343,7 +377,7 @@ void NMWirelessDevice::onConnectionLoaded(NMConnectionSettings* conn) {
 		return;
 	}
 
-	const QString ssid = settings["802-11-wireless"]["ssid"].toString();
+	const auto ssid = settings["802-11-wireless"]["ssid"].toString();
 	auto* net = this->mBackendNetworks.value(ssid);
 	if (!net) net = this->registerNetwork(ssid);
 
@@ -366,9 +400,33 @@ void NMWirelessDevice::onActiveConnectionLoaded(NMActiveConnection* active) {
 	}
 }
 
-void NMWirelessDevice::scan() {
-	this->wirelessProxy->RequestScan({});
-	this->bScanning = true;
+void NMWirelessDevice::onScanTimeout() {
+	const QDateTime now = QDateTime::currentDateTime();
+	const QDateTime lastScan = this->bLastScan;
+	const QDateTime lastScanRequest = this->mLastScanRequest;
+
+	if (lastScan.isValid() && lastScan.msecsTo(now) < this->mScanIntervalMs) {
+		// Rate limit if backend scan property updated within the interval
+		auto diff = static_cast<int>(this->mScanIntervalMs - lastScan.msecsTo(now));
+		this->mScanTimer.start(diff);
+	} else if (lastScanRequest.isValid() && lastScanRequest.msecsTo(now) < this->mScanIntervalMs) {
+		// Rate limit if frontend changes scanner state within the interval
+		auto diff = static_cast<int>(this->mScanIntervalMs - lastScanRequest.msecsTo(now));
+		this->mScanTimer.start(diff);
+	} else {
+		this->wirelessProxy->RequestScan({});
+		this->mLastScanRequest = now;
+		this->mScanTimer.start(this->mScanIntervalMs);
+	}
+}
+
+void NMWirelessDevice::handleScanner(bool enabled) {
+	if (this->mScanning == enabled) return;
+	this->mScanning = enabled;
+	for (WifiNetwork* net: this->mNetworks) {
+		updateNetworkVisibility(net);
+	}
+	enabled ? this->onScanTimeout() : this->mScanTimer.stop();
 }
 
 bool NMWirelessDevice::isWirelessValid() const {
@@ -384,4 +442,8 @@ DBusDataTransform<qs::network::NMWirelessCapabilities::Enum>::fromWire(quint32 w
 	return DBusResult(static_cast<qs::network::NMWirelessCapabilities::Enum>(wire));
 }
 
+DBusResult<QDateTime> DBusDataTransform<QDateTime>::fromWire(qint64 wire) {
+	return DBusResult(network::clockBootTimeToDateTime(wire));
+}
+
 } // namespace qs::dbus

src/network/nm/wireless.hpp

@@ -22,6 +22,13 @@ struct DBusDataTransform<qs::network::NMWirelessCapabilities::Enum> {
 	static DBusResult<Data> fromWire(Wire wire);
 };
 
+template <>
+struct DBusDataTransform<QDateTime> {
+	using Wire = qint64;
+	using Data = QDateTime;
+	static DBusResult<Data> fromWire(Wire wire);
+};
+
 } // namespace qs::dbus
 namespace qs::network {
 
@@ -97,49 +104,55 @@ class NMWirelessDevice: public NMDevice {
 	explicit NMWirelessDevice(const QString& path, QObject* parent = nullptr);
 
 	[[nodiscard]] bool isWirelessValid() const;
-	[[nodiscard]] qint64 lastScan() { return this->bLastScan; };
 	[[nodiscard]] NMWirelessCapabilities::Enum capabilities() { return this->bCapabilities; };
 	[[nodiscard]] const QDBusObjectPath& activeApPath() { return this->bActiveAccessPoint; };
-	[[nodiscard]] bool scanning() { return this->bScanning; };
 
 signals:
 	void accessPointLoaded(NMAccessPoint* ap);
 	void accessPointRemoved(NMAccessPoint* ap);
-	void wifiNetworkAdded(WifiNetwork* net);
-	void wifiNetworkRemoved(WifiNetwork* net);
+	void networkAdded(WifiNetwork* net);
+	void networkRemoved(WifiNetwork* net);
 	void activateConnection(const QDBusObjectPath& connPath, const QDBusObjectPath& devPath);
 	void addAndActivateConnection(
 	    const ConnectionSettingsMap& settings,
 	    const QDBusObjectPath& devPath,
 	    const QDBusObjectPath& apPath
 	);
-	void lastScanChanged(qint64 lastScan);
+	void lastScanChanged(QDateTime lastScan);
 	void capabilitiesChanged(NMWirelessCapabilities::Enum caps);
 	void activeAccessPointChanged(const QDBusObjectPath& path);
-	void scanningChanged(bool scanning);
 
 public slots:
-	void scan();
+	void handleScanner(bool enabled);
 
 private slots:
 	void onAccessPointPathAdded(const QDBusObjectPath& path);
 	void onAccessPointPathRemoved(const QDBusObjectPath& path);
 	void onAccessPointLoaded(NMAccessPoint* ap);
 	void onConnectionLoaded(NMConnectionSettings* conn);
 	void onActiveConnectionLoaded(NMActiveConnection* active);
+	void onScanTimeout();
 
 private:
 	void registerAccessPoint(const QString& path);
+	void updateNetworkVisibility(WifiNetwork* net);
 	void registerAccessPoints();
 	void initWireless();
 	NMWirelessNetwork* registerNetwork(const QString& ssid);
 
 	QHash<QString, NMAccessPoint*> mAccessPoints;
 	QHash<QString, NMWirelessNetwork*> mBackendNetworks;
 
+	QHash<QString, WifiNetwork*> mNetworks;
+	QSet<WifiNetwork*> mVisibleNetworks;
+
+	QDateTime mLastScanRequest;
+	QTimer mScanTimer;
+	bool mScanning = false;
+	qint32 mScanIntervalMs = 10001;
+
 	// clang-format off
-	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessDevice, qint64, bLastScan, &NMWirelessDevice::lastScanChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessDevice, bool, bScanning, &NMWirelessDevice::scanningChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessDevice, QDateTime, bLastScan, &NMWirelessDevice::lastScanChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessDevice, NMWirelessCapabilities::Enum, bCapabilities, &NMWirelessDevice::capabilitiesChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessDevice, QDBusObjectPath, bActiveAccessPoint, &NMWirelessDevice::activeAccessPointChanged);
 

src/network/test/manual/network.qml

@@ -37,9 +37,7 @@ FloatingWindow {
 			clip: true
 			Layout.fillWidth: true
 			Layout.fillHeight: true
-			model: {
-				return Network.devices.values.filter(device => device.type === DeviceType.Wifi)
-			}
+			model: Network.devices
 
 			delegate: WrapperRectangle {
 				width: parent.width
@@ -48,15 +46,6 @@ FloatingWindow {
 				border.width: 1
 				margin: 5
 
-				property var sortedNetworks: {
-					return [...modelData.networks.values].sort((a, b) => {
-						if (a.connected !== b.connected) {
-							return b.connected - a.connected
-						}
-						return b.signalStrength - a.signalStrength
-					})
-				}
-
 				ColumnLayout {
 					Label { text: `Device: ${modelData.name} (Hardware address: ${modelData.address}) (Type: ${DeviceType.toString(modelData.type)})` }
 					RowLayout {
@@ -65,24 +54,33 @@ FloatingWindow {
 							color: modelData.state == DeviceConnectionState.Connected ? palette.link : palette.placeholderText
 						}
 						Label {
-							visible: modelData.state == DeviceConnectionState.Connecting || modelData.state == DeviceConnectionState.Disconnecting
+							visible: Network.backend == NetworkBackendType.NetworkManager && (modelData.state == DeviceConnectionState.Connecting || modelData.state == DeviceConnectionState.Disconnecting)
 							text: `(${NMDeviceState.toString(modelData.nmState)})`
 						}
 						Button {
 							visible: modelData.state == DeviceConnectionState.Connected
 							text: "Disconnect"
 							onClicked: modelData.disconnect()
 						}
-						Button {
-							text: "Scan"
-							onClicked: modelData.scan()
-							visible: modelData.scanning === false
+						CheckBox {
+							text: "Scanner"
+							checked: modelData.wifiScanner.enabled
+							onClicked: modelData.wifiScanner.enabled = !modelData.wifiScanner.enabled
+							visible: modelData.type === DeviceType.Wifi
 						}
 					}
 
 					Repeater {
 						Layout.fillWidth: true
-						model: sortedNetworks
+						model: {
+							if (modelData.type !== DeviceType.Wifi) return []
+							return [...modelData.networks.values].sort((a, b) => {
+								if (a.connected !== b.connected) {
+									return b.connected - a.connected
+								}
+								return b.signalStrength - a.signalStrength
+							})
+						}
 
 						WrapperRectangle {
 							Layout.fillWidth: true
@@ -112,7 +110,7 @@ FloatingWindow {
 										}
 									}
 									Label {
-										visible: modelData.nmReason != NMConnectionStateReason.Unknown && modelData.nmReason != NMConnectionStateReason.None
+										visible: Network.backend == NetworkBackendType.NetworkManager && (modelData.nmReason != NMConnectionStateReason.Unknown && modelData.nmReason != NMConnectionStateReason.None)
 										text: `Connection change reason: ${NMConnectionStateReason.toString(modelData.nmReason)}`
 									}
 								}