feat: scan, lastScan, NetworkDeviceType

Author: cpwrs

src/network/api.cpp

@@ -13,62 +13,86 @@
 namespace qs::network {
 
 namespace {
-Q_LOGGING_CATEGORY(logNetworkDevice, "quickshell.network.device", QtWarningMsg);
+Q_LOGGING_CATEGORY(logNetworkNetworkDevice, "quickshell.network.device", QtWarningMsg);
 Q_LOGGING_CATEGORY(logNetwork, "quickshell.network", QtWarningMsg);
-}
+} // namespace
 
-Device::Device(QObject* parent): QObject(parent) {};
-WirelessDevice::WirelessDevice(QObject* parent): Device(parent) {};
+NetworkDevice::NetworkDevice(QObject* parent): QObject(parent) {};
+WirelessNetworkDevice::WirelessNetworkDevice(QObject* parent): NetworkDevice(parent) {};
 
-QString DeviceState::toString(DeviceState::Enum state) {
+QString NetworkDeviceState::toString(NetworkDeviceState::Enum state) {
 	switch (state) {
-	case DeviceState::Unknown: return QStringLiteral("Unknown");
-	case DeviceState::Disconnected: return QStringLiteral("Disconnected");
-	case DeviceState::Connecting: return QStringLiteral("Connecting");
-	case DeviceState::Connected: return QStringLiteral("Connected");
-	case DeviceState::Disconnecting: return QStringLiteral("Disconnecting");
+	case NetworkDeviceState::Unknown: return QStringLiteral("Unknown");
+	case NetworkDeviceState::Disconnected: return QStringLiteral("Disconnected");
+	case NetworkDeviceState::Connecting: return QStringLiteral("Connecting");
+	case NetworkDeviceState::Connected: return QStringLiteral("Connected");
+	case NetworkDeviceState::Disconnecting: return QStringLiteral("Disconnecting");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString NetworkDeviceType::toString(NetworkDeviceType::Enum type) {
+	switch (type) {
+	case NetworkDeviceType::Other: return QStringLiteral("Other");
+	case NetworkDeviceType::Wireless: return QStringLiteral("Wireless");
+	case NetworkDeviceType::Ethernet: return QStringLiteral("Ethernet");
 	default: return QStringLiteral("Unknown");
 	}
 }
 
-void Device::setName(const QString& name) {
+void NetworkDevice::setName(const QString& name) {
 	if (name != this->bName) {
 		this->bName = name;
 	}
 }
 
-void Device::setAddress(const QString& address) {
+void NetworkDevice::setAddress(const QString& address) {
 	if (address != this->bAddress) {
 		this->bAddress = address;
 	}
 }
 
-void Device::setState(DeviceState::Enum state) {
+void NetworkDevice::setState(NetworkDeviceState::Enum state) {
 	if (state != this->bState) {
 		this->bState = state;
 	}
 }
 
-void Device::disconnect() {
-	if (this->bState == DeviceState::Disconnected) {
-		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
+void NetworkDevice::disconnect() {
+	if (this->bState == NetworkDeviceState::Disconnected) {
+		qCCritical(logNetworkNetworkDevice) << "NetworkDevice" << this << "is already disconnected";
 		return;
 	}
 
-	if (this->bState == DeviceState::Disconnecting) {
-		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
+	if (this->bState == NetworkDeviceState::Disconnecting) {
+		qCCritical(logNetworkNetworkDevice) << "NetworkDevice" << this << "is already disconnecting";
 		return;
 	}
 
-	qCDebug(logNetworkDevice) << "Disconnecting from device" << this;
-	
+	qCDebug(logNetworkNetworkDevice) << "Disconnecting from device" << this;
+
 	signalDisconnect();
 }
 
-void WirelessDevice::setLastScan(qint64 lastScan) {
-	if (lastScan != this->bLastScan) {
-		this->bLastScan = lastScan;
+void WirelessNetworkDevice::scanComplete(qint64 lastScan) {
+	this->bLastScan = lastScan;
+	emit this->lastScanChanged();
+
+	if (this->bScanning) {
+		this->bScanning = false;
+		emit this->scanningChanged();
+	}
+}
+
+void WirelessNetworkDevice::scan() {
+	if (this->bScanning) {
+		qCCritical(logNetworkNetworkDevice) << "NetworkDevice" << this << "is already scanning";
+		return;
 	}
+
+	qCDebug(logNetworkNetworkDevice) << "Requesting scan on wireless device" << this;
+	this->bScanning = true;
+	signalScan();
 }
 
 Network::Network(QObject* parent): QObject(parent) {

src/network/api.hpp

@@ -14,9 +14,28 @@
 
 namespace qs::network {
 
-// -- Device --
 
-class DeviceState: public QObject {
+///! Type of network device.
+class NetworkDeviceType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		///! A generic device.
+		Other = 0,
+		///! An 802.11 Wi-Fi device.
+		Wireless = 1,
+		///! A wired ethernet device.
+		Ethernet = 2
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(NetworkDeviceType::Enum type);
+};
+
+///! State of a network device.
+class NetworkDeviceState: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
 	QML_SINGLETON;
@@ -35,91 +54,104 @@ class DeviceState: public QObject {
 		Connecting = 4,
 	};
 	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(DeviceState::Enum state);
+	Q_INVOKABLE static QString toString(NetworkDeviceState::Enum state);
 };
 
 ///! A tracked network device.
-class Device: public QObject {
+class NetworkDevice: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
-	QML_UNCREATABLE("Devices can only be acquired through Network");
+	QML_UNCREATABLE("NetworkDevices can only be acquired through Network");
 
 	// clang-format off
 	/// The name of the device's interface.
 	Q_PROPERTY(QString name READ default NOTIFY nameChanged BINDABLE bindableName);
 	/// The hardware address of the device's interface in the XX:XX:XX:XX:XX:XX format.
 	Q_PROPERTY(QString address READ default NOTIFY addressChanged BINDABLE bindableAddress);
 	/// Connection state of the device.
-	Q_PROPERTY(DeviceState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	Q_PROPERTY(NetworkDeviceState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	/// Type of device.
+	Q_PROPERTY(NetworkDeviceType::Enum type READ type CONSTANT);
 	// clang-format on
 
 signals:
-	void signalDisconnect();
-
-	// Frontend-facing signals
 	void nameChanged();
 	void addressChanged();
 	void stateChanged();
 
+	// For backend slots
+	void signalDisconnect();
+
 public slots:
-	// Slots for the backend to connect signals to
+	// For backend signals
 	void setName(const QString& name);
 	void setAddress(const QString& address);
-	void setState(DeviceState::Enum state);
+	void setState(NetworkDeviceState::Enum state);
 
 public:
-	explicit Device(QObject* parent = nullptr);
+	explicit NetworkDevice(QObject* parent = nullptr);
 
 	/// Disconnects the device and prevents it from automatically activating further connections.
 	Q_INVOKABLE void disconnect();
+	[[nodiscard]] virtual NetworkDeviceType::Enum type() const { return NetworkDeviceType::Other; };
 
 	[[nodiscard]] QBindable<QString> bindableName() const { return &this->bName; };
 	[[nodiscard]] QBindable<QString> bindableAddress() const { return &this->bAddress; };
-	[[nodiscard]] QBindable<DeviceState::Enum> bindableState() const { return &this->bState; };
+	[[nodiscard]] QBindable<NetworkDeviceState::Enum> bindableState() const { return &this->bState; };
 
 private:
-	Q_OBJECT_BINDABLE_PROPERTY(Device, QString, bName, &Device::nameChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(Device, QString, bAddress, &Device::addressChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(Device, DeviceState::Enum, bState, &Device::stateChanged);
+	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);
 };
 
-// -- Wireless Device --
-class WirelessDevice: public Device {
+///! Wireless variant of a tracked network device.
+class WirelessNetworkDevice: 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);
 	//clang-format on
 
 signals:
+	void signalScan();
+
+	// Frontend-facing signals
 	void lastScanChanged();
+	void scanningChanged();
 
 public slots:
-	void setLastScan(qint64 lastScan);
+	// For backend signals
+	void scanComplete(qint64 lastScan);
 
 public:
-	explicit WirelessDevice(QObject* parent = nullptr);
+	explicit WirelessNetworkDevice(QObject* parent = nullptr);
+	[[nodiscard]] NetworkDeviceType::Enum type() const override { return NetworkDeviceType::Wireless; };
 
-	// Q_INVOKABLE void disconnect();
-	// Q_INVOKABLE void scan();
+	/// Request the wireless device to scan for available WiFi networks.
+	Q_INVOKABLE void scan();
 
+	[[nodiscard]] QBindable<bool> bindableScanning() { return &this->bScanning; };
 	[[nodiscard]] QBindable<qint64> bindableLastScan() { return &this->bLastScan; };
 
 private:
 	// clang-format off
-	Q_OBJECT_BINDABLE_PROPERTY(WirelessDevice, qint64, bLastScan, &WirelessDevice::lastScanChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(WirelessNetworkDevice, bool, bScanning, &WirelessNetworkDevice::scanningChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(WirelessNetworkDevice, qint64, bLastScan, &WirelessNetworkDevice::lastScanChanged);
 	// clang-format on
 };
 
 // -- Network --
-
 class NetworkBackend: public QObject {
 	Q_OBJECT;
 
 public:
 	[[nodiscard]] virtual bool isAvailable() const = 0;
 	virtual UntypedObjectModel* devices() = 0;
-	virtual WirelessDevice* defaultWifiDevice() = 0;
+	virtual WirelessNetworkDevice* defaultWifiDevice() = 0;
 
 protected:
 	explicit NetworkBackend(QObject* parent = nullptr): QObject(parent) {};
@@ -130,13 +162,13 @@ class Network: public QObject {
 	QML_NAMED_ELEMENT(Network);
 	QML_SINGLETON;
 
-	Q_PROPERTY(WirelessDevice* defaultWifiDevice READ defaultWifiDevice CONSTANT);
+	Q_PROPERTY(WirelessNetworkDevice* defaultWifiNetworkDevice READ defaultWifiNetworkDevice CONSTANT);
 	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
 
 public:
 	explicit Network(QObject* parent = nullptr);
 	[[nodiscard]] UntypedObjectModel* devices() { return backend ? backend->devices() : nullptr; };
-	[[nodiscard]] WirelessDevice* defaultWifiDevice() {
+	[[nodiscard]] WirelessNetworkDevice* defaultWifiNetworkDevice() {
 		return backend ? backend->defaultWifiDevice() : nullptr;
 	};
 

src/network/nm_adapters.cpp

@@ -45,13 +45,13 @@ QString NMDeviceAdapter::address() const {
 }
 QString NMDeviceAdapter::path() const { return this->proxy ? this->proxy->path() : QString(); }
 
-DeviceState::Enum NMDeviceState::translate(NMDeviceState::Enum state) {
+NetworkDeviceState::Enum NMDeviceState::translate(NMDeviceState::Enum state) {
 	switch(state) {
-		case 0 ... 20: return DeviceState::Unknown;
-		case 30: return DeviceState::Disconnected;
-		case 40 ... 90: return DeviceState::Connecting;
-		case 100: return DeviceState::Connected;
-		case 110 ... 120: return DeviceState::Disconnecting;
+		case 0 ... 20: return NetworkDeviceState::Unknown;
+		case 30: return NetworkDeviceState::Disconnected;
+		case 40 ... 90: return NetworkDeviceState::Connecting;
+		case 100: return NetworkDeviceState::Connected;
+		case 110 ... 120: return NetworkDeviceState::Disconnecting;
 	}
 }
 
@@ -74,6 +74,7 @@ void NMWirelessAdapter::init(const QString& path) {
 	this->wirelessProperties.updateAllViaGetAll();
 }
 
+void NMWirelessAdapter::scan() { this->proxy->RequestScan(); }
 bool NMWirelessAdapter::isValid() const { return this->proxy && this->proxy->isValid(); }
 QString NMWirelessAdapter::address() const {
 	return this->proxy ? this->proxy->service() : QString();

src/network/nm_adapters.hpp

@@ -38,7 +38,7 @@ class NMDeviceState: public QObject {
 	};
 	Q_ENUM(Enum);
 
-	static DeviceState::Enum translate(NMDeviceState::Enum state);
+	static NetworkDeviceState::Enum translate(NMDeviceState::Enum state);
 };
 
 class NMDeviceType: public QObject {
@@ -156,16 +156,18 @@ class NMWirelessAdapter: public QObject {
 	[[nodiscard]] QString address() const;
 	[[nodiscard]] qint64 getLastScan() { return this->bLastScan; };
 
+public slots:
+	void scan();
+
 signals:
-	void lastScanChanged(qint64 time);
+	void lastScanChanged(qint64 lastScan);
 
 private:
 	// clang-format off
 	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessAdapter, qint64, bLastScan, &NMWirelessAdapter::lastScanChanged);
 
 	QS_DBUS_BINDABLE_PROPERTY_GROUP(NMWirelessAdapter, wirelessProperties);
 	QS_DBUS_PROPERTY_BINDING(NMWirelessAdapter, pLastScan, bLastScan, wirelessProperties, "LastScan");
-
 	DBusNMWirelessProxy* proxy = nullptr;
 };
 } // namespace qs::network