i3/sway: use datastreams instead of qbytearrays for socket reading

Author: nydragon

src/x11/i3/ipc/connection.cpp

@@ -31,19 +31,19 @@ Q_LOGGING_CATEGORY(logI3IpcEvents, "quickshell.I3.ipc.events", QtWarningMsg);
 namespace qs::i3::ipc {
 
 QVector<Event> I3Ipc::makeRequest(const QByteArray& request) {
+
 this->commandSocket.write(request);
 this->commandSocket.flush();
 
 if (this->commandSocket.waitForReadyRead()) {
-auto dataRaw = this->commandSocket.readAll();
-return I3Ipc::parseResponse(dataRaw);
+return I3Ipc::parseResponse(this->commandSocketDs);
 } else {
 qCWarning(logI3Ipc) << "Timeout while waiting for read for" << request;
 return {};
 }
 }
 
-void I3Ipc::dispatch(const QString& payload) {
+QJsonArray I3Ipc::dispatch(const QString& payload) {
 auto message = I3Ipc::buildRequestMessage(EventCode::RUN_COMMAND, payload.toLocal8Bit());
 
 QVector<Event> res = this->makeRequest(message);
@@ -63,6 +63,8 @@ void I3Ipc::dispatch(const QString& payload) {
  << jsonMessage["error"];
 }
 }
+
+return data.array();
 }
 
 QByteArray I3Ipc::buildRequestMessage(EventCode cmd, const QByteArray& payload) {
@@ -102,6 +104,7 @@ I3Ipc::I3Ipc() {
 
 this->liveEventSocket.write(message);
 this->liveEventSocket.flush();
+emit this->connected();
 };
 
 QObject::connect(
@@ -111,90 +114,70 @@ I3Ipc::I3Ipc() {
  liveIPCconnectedCallback
 );
 
+this->liveEventSocketDs.setDevice(&this->liveEventSocket);
+this->commandSocketDs.setDevice(&this->commandSocket);
+this->liveEventSocketDs.setByteOrder(static_cast<QDataStream::ByteOrder>(QSysInfo::ByteOrder));
+this->commandSocketDs.setByteOrder(static_cast<QDataStream::ByteOrder>(QSysInfo::ByteOrder));
+
 this->liveEventSocket.connectToServer(this->mSocketPath);
 this->commandSocket.connectToServer(this->mSocketPath);
-
 this->refreshWorkspaces();
 this->refreshMonitors();
 }
 
 void I3Ipc::eventSocketReady() {
-while (true) {
-auto rawEvent = this->liveEventSocket.readAll();
-if (rawEvent.isEmpty()) break;
-
-for (auto& [type, data]: I3Ipc::parseResponse(rawEvent)) {
-this->event.mCode = type;
-this->event.mData = data;
+for (auto& [type, data]: I3Ipc::parseResponse(this->liveEventSocketDs)) {
+this->event.mCode = type;
+this->event.mData = data;
 
-this->onEvent(&this->event);
-emit this->rawEvent(&this->event);
-}
+this->onEvent(&this->event);
+emit this->rawEvent(&this->event);
 }
 }
 
-QVector<Event> I3Ipc::parseResponse(QByteArray rawEvent) {
+QVector<Event> I3Ipc::parseResponse(QDataStream& rawEvent) {
 QVector<std::tuple<EventCode, QJsonDocument>> events;
 const int magicLen = 6;
-const int header = 8 + magicLen;
 
-while (!rawEvent.isEmpty()) {
-auto magicSeqInd = rawEvent.indexOf(MAGIC);
+while (!rawEvent.atEnd()) {
+rawEvent.startTransaction();
 
-if (magicSeqInd < 0) {
-qCWarning(logI3Ipc) << "No magic sequence found in string.";
-break;
-};
-
-if (magicSeqInd > 0) {
-rawEvent = rawEvent.sliced(magicSeqInd);
-}
+QByteArray buffer(6, 0);
+qint32 size = 0;
+qint32 type = EventCode::UNKNOWN;
 
-auto eventLength = rawEvent.length();
+rawEvent.readRawData(buffer.data(), magicLen);
+rawEvent >> size;
+rawEvent >> type;
 
-if (eventLength < header) {
-qCWarning(logI3Ipc) << "Event isn't long enough to hold the header data (14 bytes).";
+if (buffer != MAGIC.data()) {
+qCWarning(logI3Ipc) << "No magic sequence found in string." << buffer;
+rawEvent.rollbackTransaction();
 break;
 };
 
-rawEvent = rawEvent.sliced(magicLen);
-
-QDataStream ds(rawEvent);
-
-ds.setByteOrder(static_cast<QDataStream::ByteOrder>(QSysInfo::ByteOrder));
-
-qint32 size = 0;
-qint32 type = EventCode::UNKNOWN;
-
-ds >> size;
-ds >> type;
-
 if (I3IpcEvent::intToEvent(type) == EventCode::UNKNOWN) {
-qCWarning(logI3Ipc) << "Received unknown event" << rawEvent;
+qCWarning(logI3Ipc) << "Received unknown event";
+rawEvent.rollbackTransaction();
 break;
 }
 
-auto maxPayloadLength = eventLength - header;
+QByteArray payload(size, Qt::Uninitialized);
 
-if (maxPayloadLength < size) {
-qCWarning(logI3Ipc) << "Payload is smaller than length advertised in header, skipping... ("
- << maxPayloadLength << "vs" << size << ")";
-break;
-}
-
-rawEvent = rawEvent.sliced(8);
+rawEvent.readRawData(payload.data(), size);
 
 QJsonParseError e;
 
-auto data = QJsonDocument::fromJson(rawEvent.sliced(0, size), &e);
+auto data = QJsonDocument::fromJson(payload, &e);
 
 if (e.error != QJsonParseError::NoError) {
-qCWarning(logI3Ipc) << "Invalid JSON value:" << e.errorString() << "\n\t" << rawEvent;
+qCWarning(logI3Ipc) << "Invalid JSON value:" << e.errorString();
+rawEvent.rollbackTransaction();
+break;
 } else {
+if (!rawEvent.commitTransaction()) break;
 events.push_back(std::tuple(I3IpcEvent::intToEvent(type), data));
 }
-
-rawEvent = rawEvent.sliced(size);
 }
 
 return events;
@@ -234,6 +217,10 @@ void I3Ipc::setFocusedWorkspace(I3Workspace* workspace) {
 this->mFocusedWorkspace = workspace;
 
 if (workspace != nullptr) {
+if (auto* monitor = this->mFocusedWorkspace->monitor()) {
+monitor->setFocusedWorkspace(this->mFocusedWorkspace);
+}
+
 QObject::connect(workspace, &QObject::destroyed, this, &I3Ipc::onFocusedWorkspaceDestroyed);
 workspace->setFocus(true);
 this->setFocusedMonitor(workspace->monitor());
@@ -428,28 +415,37 @@ void I3Ipc::handleWorkspaceEvent(I3IpcEvent* event) {
 
 auto workspaceData = event->mData["current"];
 
-auto* workspace = new I3Workspace(this);
+auto* workspace = this->findWorkspaceByID(workspaceData["id"].toInt(-1));
+
+if (workspace == nullptr) {
+workspace = new I3Workspace(this);
+}
 
 if (workspaceData.isObject()) {
 workspace->updateFromObject(workspaceData.toObject().toVariantMap());
 }
 
 this->mWorkspaces.insertObject(workspace);
 qCInfo(logI3Ipc) << "Added workspace to list";
-
 } else if (change == "focus") {
 auto oldData = event->mData["old"];
 auto newData = event->mData["current"];
 auto oldName = oldData["name"].toString();
 auto newName = newData["name"].toString();
 
 qCInfo(logI3IpcEvents) << "Focus changed: " << oldName << "->" << newName;
-auto* oldWorkspace = this->findWorkspaceByName(oldName);
+
+if (auto* oldWorkspace = this->findWorkspaceByName(oldName)) {
+oldWorkspace->updateFromObject(oldData.toObject().toVariantMap());
+}
+
 auto* newWorkspace = this->findWorkspaceByName(newName);
 
-oldWorkspace->updateFromObject(oldData.toObject().toVariantMap());
-newWorkspace->updateFromObject(newData.toObject().toVariantMap());
+if (newWorkspace == nullptr) {
+newWorkspace = new I3Workspace(this);
+}
 
+newWorkspace->updateFromObject(newData.toObject().toVariantMap());
 this->setFocusedWorkspace(newWorkspace);
 } else if (change == "empty") {
 auto name = event->mData["current"]["name"].toString();
@@ -493,6 +489,14 @@ I3Monitor* I3Ipc::monitorFor(QuickshellScreenInfo* screen) {
 return this->findMonitorByName(screen->name());
 }
 
+I3Workspace* I3Ipc::findWorkspaceByID(qint32 id) {
+auto list = this->mWorkspaces.valueList();
+auto workspaceIter =
+ std::find_if(list.begin(), list.end(), [id](const I3Workspace* m) { return m->id() == id; });
+
+return workspaceIter == list.end() ? nullptr : *workspaceIter;
+}
+
 I3Workspace* I3Ipc::findWorkspaceByName(const QString& name) {
 auto list = this->mWorkspaces.valueList();
 auto workspaceIter = std::find_if(list.begin(), list.end(), [name](const I3Workspace* m) {

src/x11/i3/ipc/connection.hpp

@@ -75,11 +75,13 @@ class I3Ipc: public QObject {
 [[nodiscard]] QString socketPath() const;
 
 QVector<Event> makeRequest(const QByteArray& request);
-void dispatch(const QString& payload);
+QJsonArray dispatch(const QString& payload);
 
 static QByteArray buildRequestMessage(EventCode cmd, const QByteArray& payload = QByteArray());
+
 I3Workspace* findWorkspaceByName(const QString& name);
 I3Monitor* findMonitorByName(const QString& name);
+I3Workspace* findWorkspaceByID(qint32 id);
 
 void setFocusedWorkspace(I3Workspace* workspace);
 void setFocusedMonitor(I3Monitor* monitor);
@@ -114,11 +116,16 @@ private slots:
 
 void handleWorkspaceEvent(I3IpcEvent* event);
 
-static QVector<std::tuple<EventCode, QJsonDocument>> parseResponse(QByteArray rawEvent);
+static QVector<std::tuple<EventCode, QJsonDocument>> parseResponse(QDataStream& rawEvent);
 
 QLocalSocket liveEventSocket;
+QDataStream liveEventSocketDs;
+
 QLocalSocket commandSocket;
+QDataStream commandSocketDs;
+
 QString mSocketPath;
+
 bool valid = false;
 
 ObjectModel<I3Monitor> mMonitors {this};

src/x11/i3/ipc/monitor.cpp

@@ -12,7 +12,7 @@ namespace qs::i3::ipc {
 qint32 I3Monitor::id() const { return this->mId; };
 QString I3Monitor::name() const { return this->mName; };
 bool I3Monitor::power() const { return this->mPower; };
-I3Workspace* I3Monitor::activeWorkspace() const { return this->mActiveWorkspace; };
+I3Workspace* I3Monitor::focusedWorkspace() const { return this->mFocusedWorkspace; };
 qint32 I3Monitor::x() const { return this->mX; };
 qint32 I3Monitor::y() const { return this->mY; };
 qint32 I3Monitor::width() const { return this->mWidth; };
@@ -49,16 +49,16 @@ void I3Monitor::updateFromObject(const QVariantMap& obj) {
 this->powerChanged();
 }
 
-if (activeWorkspaceId != this->mActiveWorkspaceId) {
+if (activeWorkspaceId != this->mFocusedWorkspaceName) {
 auto* workspace = this->ipc->findWorkspaceByName(activeWorkspaceId);
 if (activeWorkspaceId.isEmpty() || workspace == nullptr) { // is null when output is disabled
-this->mActiveWorkspace = nullptr;
-this->mActiveWorkspaceId = "";
+this->mFocusedWorkspace = nullptr;
+this->mFocusedWorkspaceName = "";
 } else {
-this->mActiveWorkspaceId = activeWorkspaceId;
-this->mActiveWorkspace = workspace;
+this->mFocusedWorkspaceName = activeWorkspaceId;
+this->mFocusedWorkspace = workspace;
 }
-emit this->activeWorkspaceChanged();
+emit this->focusedWorkspaceChanged();
 };
 
 if (x != this->mX) {
@@ -97,5 +97,15 @@ void I3Monitor::updateFromObject(const QVariantMap& obj) {
 }
 }
 
-void I3Monitor::setFocus(bool focused) { this->mFocused = focused; }
+void I3Monitor::setFocus(bool focused) {
+this->mFocused = focused;
+emit this->focusedChanged();
+}
+
+void I3Monitor::setFocusedWorkspace(I3Workspace* workspace) {
+this->mFocusedWorkspace = workspace;
+this->mFocusedWorkspaceName = workspace->name();
+emit this->focusedWorkspaceChanged();
+};
+
 } // namespace qs::i3::ipc

src/x11/i3/ipc/monitor.hpp

@@ -17,10 +17,9 @@ class I3Monitor: public QObject {
 /// Wether this monitor is turned on or not
 Q_PROPERTY(bool power READ power NOTIFY powerChanged);
 
-/// The currently active workspace
-/// TODO: replace with a list of all workspaces
-Q_PROPERTY(qs::i3::ipc::I3Workspace* activeWorkspace READ activeWorkspace NOTIFY
- activeWorkspaceChanged);
+/// The current workspace
+Q_PROPERTY(qs::i3::ipc::I3Workspace* focusedWorkspace READ focusedWorkspace NOTIFY
+ focusedWorkspaceChanged);
 
 /// The X coordinate of this monitor inside the monitor layout
 Q_PROPERTY(qint32 x READ x NOTIFY xChanged);
@@ -54,7 +53,7 @@ class I3Monitor: public QObject {
 [[nodiscard]] qint32 id() const;
 [[nodiscard]] QString name() const;
 [[nodiscard]] bool power() const;
-[[nodiscard]] I3Workspace* activeWorkspace() const;
+[[nodiscard]] I3Workspace* focusedWorkspace() const;
 [[nodiscard]] qint32 x() const;
 [[nodiscard]] qint32 y() const;
 [[nodiscard]] qint32 width() const;
@@ -65,12 +64,13 @@ class I3Monitor: public QObject {
 
 void updateFromObject(const QVariantMap& obj);
 
+void setFocusedWorkspace(I3Workspace* workspace);
 void setFocus(bool focus);
 signals:
 void idChanged();
 void nameChanged();
 void powerChanged();
-void activeWorkspaceChanged();
+void focusedWorkspaceChanged();
 void xChanged();
 void yChanged();
 void widthChanged();
@@ -93,8 +93,8 @@ class I3Monitor: public QObject {
 bool mFocused = false;
 QVariantMap mLastIpcObject;
 
-I3Workspace* mActiveWorkspace = nullptr;
-QString mActiveWorkspaceId; // use for faster change detection
+I3Workspace* mFocusedWorkspace = nullptr;
+QString mFocusedWorkspaceName; // use for faster change detection
 };
 
 } // namespace qs::i3::ipc

src/x11/i3/ipc/qml.cpp

@@ -1,5 +1,6 @@
 #include "qml.hpp"
 
+#include <qjsonarray.h>
 #include <qobject.h>
 #include <qstring.h>
 
@@ -24,7 +25,9 @@ I3IpcQml::I3IpcQml() {
 QObject::connect(instance, &I3Ipc::focusedMonitorChanged, this, &I3IpcQml::focusedMonitorChanged);
 }
 
-void I3IpcQml::dispatch(const QString& request) { I3Ipc::instance()->dispatch(request); }
+QJsonArray I3IpcQml::dispatch(const QString& request) {
+return I3Ipc::instance()->dispatch(request);
+}
 
 void I3IpcQml::refreshMonitors() { I3Ipc::instance()->refreshMonitors(); }
 

src/x11/i3/ipc/qml.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <qjsonarray.h>
 #include <qobject.h>
 
 #include "../../../core/doc.hpp"
@@ -31,7 +32,7 @@ class I3IpcQml: public QObject {
 explicit I3IpcQml();
 
 /// Execute an [I3/Sway command](https://i3wm.org/docs/userguide.html#list_of_commands)
-Q_INVOKABLE static void dispatch(const QString& request);
+Q_INVOKABLE static QJsonArray dispatch(const QString& request);
 
 /// Refresh monitor information.
 Q_INVOKABLE static void refreshMonitors();