network: update API

A few changes to the frontend Network API:
- Expose all devices at the toplevel
- Move wifi rfkill options to the toplevel
- Add WifiSecurityType (backend agnostic)
- Move WifiNetwork signal strength to a qreal from 0.0 to 1.0
- Add extensible BaseNetwork class

Author: cpwrs

src/network/device.cpp

@@ -14,43 +14,38 @@ namespace {
 QS_LOGGING_CATEGORY(logNetworkDevice, "quickshell.network.device", QtWarningMsg);
 } // namespace
 
-NetworkDevice::NetworkDevice(QObject* parent): QObject(parent) {};
-
-void NetworkDevice::disconnect() {
-	if (this->bState == NetworkConnectionState::Disconnected) {
-		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
-		return;
-	}
-	if (this->bState == NetworkConnectionState::Disconnecting) {
-		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
-		return;
-	}
-	qCDebug(logNetworkDevice) << "Disconnecting from device" << this;
-	this->requestDisconnect();
-}
-
-QString NetworkConnectionState::toString(NetworkConnectionState::Enum state) {
+QString DeviceConnectionState::toString(DeviceConnectionState::Enum state) {
 	switch (state) {
 	case Unknown: return QStringLiteral("Unknown");
 	case Connecting: return QStringLiteral("Connecting");
 	case Connected: return QStringLiteral("Connected");
 	case Disconnecting: return QStringLiteral("Disconnecting");
 	case Disconnected: return QStringLiteral("Disconnected");
-	default: return QStringLiteral("Unknown");
 	}
 }
 
-} // namespace qs::network
+QString DeviceType::toString(DeviceType::Enum type) {
+	switch (type) {
+	case None: return QStringLiteral("None");
+	case Wifi: return QStringLiteral("Wifi");
+	}
+}
 
-QDebug operator<<(QDebug debug, const qs::network::NetworkDevice* device) {
-	auto saver = QDebugStateSaver(debug);
+NetworkDevice::NetworkDevice(DeviceType::Enum type, QObject* parent)
+    : QObject(parent)
+    , mType(type) {};
 
-	if (device) {
-		debug.nospace() << "NetworkDevice(" << static_cast<const void*>(device)
-		                << ", name=" << device->name() << ")";
-	} else {
-		debug << "BluetoothDevice(nullptr)";
+void NetworkDevice::disconnect() {
+	if (this->bState == DeviceConnectionState::Disconnected) {
+		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
+		return;
 	}
-
-	return debug;
+	if (this->bState == DeviceConnectionState::Disconnecting) {
+		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
+		return;
+	}
+	qCDebug(logNetworkDevice) << "Disconnecting from device" << this;
+	this->requestDisconnect();
 }
+
+} // namespace qs::network

src/network/device.hpp

@@ -10,8 +10,8 @@
 
 namespace qs::network {
 
-///! Connection state.
-class NetworkConnectionState: public QObject {
+///! Connection state of a NetworkDevice.
+class DeviceConnectionState: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
 	QML_SINGLETON;
@@ -25,37 +25,56 @@ class NetworkConnectionState: public QObject {
 		Disconnected = 4,
 	};
 	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(NetworkConnectionState::Enum state);
+	Q_INVOKABLE static QString toString(DeviceConnectionState::Enum state);
 };
 
-///! A Network device.
+///! Type of network device.
+class DeviceType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		None = 0,
+		Wifi = 1,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(DeviceType::Enum type);
+};
+
+
+///! A network device.
 class NetworkDevice: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
 	QML_UNCREATABLE("Devices can only be acquired through Network");
 	// clang-format off
+	/// The device type.
+	Q_PROPERTY(DeviceType::Enum type READ type CONSTANT);
 	/// The name of the device's control interface.
 	Q_PROPERTY(QString name READ name NOTIFY nameChanged BINDABLE bindableName);
 	/// The hardware address of the device in the XX:XX:XX:XX:XX:XX format.
 	Q_PROPERTY(QString address READ address NOTIFY addressChanged BINDABLE bindableAddress);
 	/// Connection state of the device.
-	Q_PROPERTY(qs::network::NetworkConnectionState::Enum state READ state NOTIFY stateChanged BINDABLE bindableState);
+	Q_PROPERTY(qs::network::DeviceConnectionState::Enum state READ state NOTIFY stateChanged BINDABLE bindableState);
 	/// A more specific device state when the backend is NetworkManager.
 	Q_PROPERTY(qs::network::NMDeviceState::Enum nmState READ nmState NOTIFY nmStateChanged BINDABLE bindableNmState);
 	// clang-format on
 
 public:
-	explicit NetworkDevice(QObject* parent = nullptr);
+	explicit NetworkDevice(DeviceType::Enum type, QObject* parent = nullptr);
 
 	/// Disconnects the device and prevents it from automatically activating further connections.
 	Q_INVOKABLE void disconnect();
 
+	[[nodiscard]] DeviceType::Enum type() const { return this->mType; };
 	QBindable<QString> bindableName() { return &this->bName; };
 	[[nodiscard]] QString name() const { return this->bName; };
 	QBindable<QString> bindableAddress() { return &this->bAddress; };
 	[[nodiscard]] QString address() const { return this->bAddress; };
-	QBindable<NetworkConnectionState::Enum> bindableState() { return &this->bState; };
-	[[nodiscard]] NetworkConnectionState::Enum state() const { return this->bState; };
+	QBindable<DeviceConnectionState::Enum> bindableState() { return &this->bState; };
+	[[nodiscard]] DeviceConnectionState::Enum state() const { return this->bState; };
 	QBindable<NMDeviceState::Enum> bindableNmState() { return &this->bNmState; };
 	[[nodiscard]] NMDeviceState::Enum nmState() const { return this->bNmState; };
 
@@ -67,14 +86,13 @@ class NetworkDevice: public QObject {
 	void nmStateChanged();
 
 private:
+	DeviceType::Enum mType;
 	// clang-format off
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bName, &NetworkDevice::nameChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bAddress, &NetworkDevice::addressChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, NetworkConnectionState::Enum, bState, &NetworkDevice::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, DeviceConnectionState::Enum, bState, &NetworkDevice::stateChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, NMDeviceState::Enum, bNmState, &NetworkDevice::nmStateChanged);
 	// clang-format on
 };
 
 } // namespace qs::network
-
-QDebug operator<<(QDebug debug, const qs::network::NetworkDevice* device);

src/network/network.cpp

@@ -6,24 +6,22 @@
 
 #include "../core/logcat.hpp"
 #include "nm/backend.hpp"
-#include "wifi.hpp"
 
 namespace qs::network {
 
 namespace {
 QS_LOGGING_CATEGORY(logNetwork, "quickshell.network", QtWarningMsg);
 } // namespace
 
-Network::Network(QObject* parent): QObject(parent), mWifi(new Wifi(this)) {
+Network::Network(QObject* parent): QObject(parent) {
 	// NetworkManager
 	auto* nm = new NetworkManager(this);
 	if (nm->isAvailable()) {
-		QObject::connect(nm, &NetworkManager::wifiDeviceAdded, this->wifi(), &Wifi::onDeviceAdded);
-		QObject::connect(nm, &NetworkManager::wifiDeviceRemoved, this->wifi(), &Wifi::onDeviceRemoved);
-		this->wifi()->bindableEnabled().setBinding([nm]() { return nm->wifiEnabled(); });
-		this->wifi()->bindableHardwareEnabled().setBinding([nm]() { return nm->wifiHardwareEnabled(); }
-		);
-		QObject::connect(this->wifi(), &Wifi::requestSetEnabled, nm, &NetworkManager::setWifiEnabled);
+		QObject::connect(nm, &NetworkManager::deviceAdded, this, &Network::onDeviceAdded);
+		QObject::connect(nm, &NetworkManager::deviceRemoved, this, &Network::onDeviceRemoved);
+		this->bindableWifiEnabled().setBinding([nm]() { return nm->wifiEnabled(); });
+		this->bindableWifiHardwareEnabled().setBinding([nm]() { return nm->wifiHardwareEnabled(); });
+		QObject::connect(this, &Network::requestSetWifiEnabled, nm, &NetworkManager::setWifiEnabled);
 		this->mBackend = nm;
 		this->mBackendType = NetworkBackendType::NetworkManager;
 		return;
@@ -34,4 +32,18 @@ Network::Network(QObject* parent): QObject(parent), mWifi(new Wifi(this)) {
 	qCCritical(logNetwork) << "Network will not work. Could not find an available backend.";
 }
 
+void Network::onDeviceAdded(NetworkDevice* dev) { this->mDevices.insertObject(dev); }
+void Network::onDeviceRemoved(NetworkDevice* dev) { this->mDevices.removeObject(dev); }
+
+void Network::setWifiEnabled(bool enabled) {
+	if (this->bWifiEnabled == enabled) {
+		const QString state = enabled ? "enabled" : "disabled";
+		qCCritical(logNetwork) << "Wifi is already software" << state;
+	} else {
+		emit this->requestSetWifiEnabled(enabled);
+	}
+}
+
+BaseNetwork::BaseNetwork(QString name, QObject* parent): QObject(parent), mName(std::move(name)) {};
+
 } // namespace qs::network

src/network/network.hpp

@@ -6,7 +6,8 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
-#include "wifi.hpp"
+#include "../core/model.hpp"
+#include "device.hpp"
 
 namespace qs::network {
 
@@ -41,22 +42,72 @@ class Network: public QObject {
 	Q_OBJECT;
 	QML_SINGLETON;
 	QML_NAMED_ELEMENT(Network);
-
-	/// The wifi device service.
-	Q_PROPERTY(qs::network::Wifi* wifi READ wifi CONSTANT);
+	// clang-format off
+	/// A list of all network devices.
+	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::Network::Device>*);
 	/// The backend being used to power the Network service.
 	Q_PROPERTY(qs::network::NetworkBackendType::Enum backend READ backend CONSTANT);
+	/// Master switch for the status of the rfkill software block of all wireless devices.
+	Q_PROPERTY(bool wifiEnabled READ wifiEnabled WRITE setWifiEnabled NOTIFY wifiEnabledChanged);
+	/// Master switch for the status of the rfkill hardware block of all wireless devices.
+	Q_PROPERTY(bool wifiHardwareEnabled READ wifiHardwareEnabled NOTIFY wifiHardwareEnabledChanged BINDABLE bindableWifiHardwareEnabled);
+	// clang-format on
 
 public:
 	explicit Network(QObject* parent = nullptr);
 
-	[[nodiscard]] Wifi* wifi() const { return this->mWifi; };
+	[[nodiscard]] ObjectModel<NetworkDevice>* devices() { return &this->mDevices; };
 	[[nodiscard]] NetworkBackendType::Enum backend() const { return this->mBackendType; };
+	QBindable<bool> bindableWifiEnabled() { return &this->bWifiEnabled; };
+	[[nodiscard]] bool wifiEnabled() const { return this->bWifiEnabled; };
+	void setWifiEnabled(bool enabled);
+	QBindable<bool> bindableWifiHardwareEnabled() { return &this->bWifiHardwareEnabled; };
+	[[nodiscard]] bool wifiHardwareEnabled() const { return this->bWifiHardwareEnabled; };
+
+signals:
+	void requestSetWifiEnabled(bool enabled);
+	void wifiEnabledChanged();
+	void wifiHardwareEnabledChanged();
+
+public slots:
+	void onDeviceAdded(NetworkDevice* dev);
+	void onDeviceRemoved(NetworkDevice* dev);
 
 private:
-	Wifi* mWifi;
+	ObjectModel<NetworkDevice> mDevices {this};
 	NetworkBackend* mBackend = nullptr;
 	NetworkBackendType::Enum mBackendType = NetworkBackendType::None;
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bWifiEnabled, &Network::wifiEnabledChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bWifiHardwareEnabled, &Network::wifiHardwareEnabledChanged);
+	// clang-format on
+};
+
+///! A base network.
+class BaseNetwork: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("BaseNetwork can only be aqcuired through network devices");
+
+	/// The name of the network
+	Q_PROPERTY(QString name READ name CONSTANT);
+	/// True if the network is connected to.
+	Q_PROPERTY(bool connected READ connected NOTIFY connectedChanged BINDABLE bindableConnected);
+
+public:
+	explicit BaseNetwork(QString name, QObject* parent = nullptr);
+
+	[[nodiscard]] QString name() const { return this->mName; };
+	QBindable<bool> bindableConnected() { return &this->bConnected; }
+	[[nodiscard]] bool connected() const { return this->bConnected; };
+
+signals:
+	void connectedChanged();
+
+protected:
+	QString mName;
+	Q_OBJECT_BINDABLE_PROPERTY(BaseNetwork, bool, bConnected, &BaseNetwork::connectedChanged);
 };
 
 } // namespace qs::network

src/network/nm/backend.cpp

@@ -131,16 +131,6 @@ void NetworkManager::registerDevice(const QString& path) {
 	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
 }
 
-NetworkConnectionState::Enum NetworkManager::toNetworkDeviceState(NMDeviceState::Enum state) {
-	switch (state) {
-	case 0 ... 20: return NetworkConnectionState::Unknown;
-	case 30: return NetworkConnectionState::Disconnected;
-	case 40 ... 90: return NetworkConnectionState::Connecting;
-	case 100: return NetworkConnectionState::Connected;
-	case 110 ... 120: return NetworkConnectionState::Disconnecting;
-	}
-}
-
 void NetworkManager::registerWifiDevice(const QString& path) {
 	auto* wireless = new NMWirelessDevice(path);
 	if (!wireless->isWirelessValid() || !wireless->isDeviceValid()) {
@@ -157,7 +147,13 @@ void NetworkManager::registerWifiDevice(const QString& path) {
 	device->bindableAddress().setBinding([wireless]() { return wireless->hwAddress(); });
 	device->bindableNmState().setBinding([wireless]() { return wireless->state(); });
 	device->bindableState().setBinding([wireless]() {
-		return qs::network::NetworkManager::toNetworkDeviceState(wireless->state());
+		switch (wireless->state()) {
+		case 0 ... 20: return DeviceConnectionState::Unknown;
+		case 30: return DeviceConnectionState::Disconnected;
+		case 40 ... 90: return DeviceConnectionState::Connecting;
+		case 100: return DeviceConnectionState::Connected;
+		case 110 ... 120: return DeviceConnectionState::Disconnecting;
+		}
 	});
 	device->bindableScanning().setBinding([wireless]() { return wireless->scanning(); });
 	// clang-format off
@@ -169,7 +165,7 @@ void NetworkManager::registerWifiDevice(const QString& path) {
 	QObject::connect(device, &WifiDevice::requestDisconnect, wireless, &NMWirelessDevice::disconnect);
 	// clang-format on
 
-	emit this->wifiDeviceAdded(device);
+	emit this->deviceAdded(device);
 }
 
 void NetworkManager::onDevicePathAdded(const QDBusObjectPath& path) {
@@ -184,7 +180,7 @@ void NetworkManager::onDevicePathRemoved(const QDBusObjectPath& path) {
 	} else {
 		auto* device = iter.value();
 		this->mDeviceHash.erase(iter);
-		if (auto* wifi = qobject_cast<WifiDevice*>(device)) emit this->wifiDeviceRemoved(wifi);
+		emit this->deviceRemoved(device);
 		delete device;
 	}
 }

src/network/nm/backend.hpp

@@ -25,8 +25,8 @@ class NetworkManager: public NetworkBackend {
 	[[nodiscard]] bool wifiHardwareEnabled() const { return this->bWifiHardwareEnabled; };
 
 signals:
-	void wifiDeviceAdded(WifiDevice* device);
-	void wifiDeviceRemoved(WifiDevice* device);
+	void deviceAdded(NetworkDevice* device);
+	void deviceRemoved(NetworkDevice* device);
 	void wifiEnabledChanged(bool enabled);
 	void wifiHardwareEnabledChanged(bool enabled);
 
@@ -44,7 +44,6 @@ private slots:
 	);
 
 private:
-	static NetworkConnectionState::Enum toNetworkDeviceState(NMDeviceState::Enum state);
 	void init();
 	void registerDevices();
 	void registerDevice(const QString& path);