Streamline Callbacks

Lord-Grey · Lord-Grey · commit 2e4942adc6f9 · 2024-11-29T09:36:02.000+01:00
diff --git a/include/api/JsonAPI.h b/include/api/JsonAPI.h
@@ -50,6 +50,8 @@ class JsonAPI : public API
 	///
 	void initialize();
 
+	QSharedPointer<JsonCallbacks> JsonAPI::getCallBack() const;
+
 public slots:
 
 private slots:
@@ -82,7 +84,7 @@ private slots:
 	///
 	/// Signal emits with the reply message provided with handleMessage()
 	///
-	void callbackMessage(QJsonObject);
+	void callbackReady(QJsonObject);
 
 	///
 	/// Signal emits whenever a JSON-message should be forwarded
diff --git a/include/api/JsonCallbacks.h b/include/api/JsonCallbacks.h
@@ -93,7 +93,7 @@ class JsonCallbacks : public QObject
 	/// @brief Emits whenever a new json mesage callback is ready to send
 	/// @param The JsonObject message
 	///
-	void newCallback(QJsonObject);
+	void callbackReady(QJsonObject);
 
 private slots:
 	///
@@ -182,6 +182,8 @@ private slots:
 
 	/// construct callback msg
 	void doCallback(Subscription::Type cmd, const QVariant& data);
+	void doCallback(Subscription::Type cmd, const QJsonArray& data);
+	void doCallback(Subscription::Type cmd, const QJsonObject& data);
 
 	Logger *_log;
 	Hyperion* _hyperion;
diff --git a/libsrc/api/JsonAPI.cpp b/libsrc/api/JsonAPI.cpp
@@ -85,6 +85,11 @@ JsonAPI::JsonAPI(QString peerAddress, Logger *log, bool localConnection, QObject
 	_jsonCB = QSharedPointer<JsonCallbacks>(new JsonCallbacks( _log, _peerAddress, parent));
 }
 
+QSharedPointer<JsonCallbacks> JsonAPI::getCallBack() const
+{
+	return _jsonCB;
+}
+
 void JsonAPI::initialize()
 {
 	// init API, REQUIRED!
@@ -97,9 +102,6 @@ void JsonAPI::initialize()
 	// listen for killed instances
 	connect(_instanceManager, &HyperionIManager::instanceStateChanged, this, &JsonAPI::handleInstanceStateChange);
 
-	// pipe callbacks from subscriptions to parent
-	connect(_jsonCB.data(), &JsonCallbacks::newCallback, this, &JsonAPI::callbackMessage);
-
 	// notify hyperion about a jsonMessageForward
 	if (_hyperion != nullptr)
 	{
@@ -1537,7 +1539,7 @@ void JsonAPI::sendSuccessReply(const JsonApiCommand& cmd)
 
 void JsonAPI::sendSuccessReply(const QString &command, int tan, InstanceCmd::Type isInstanceCmd)
 {
-	emit callbackMessage(getBasicCommandReply(true, command, tan , isInstanceCmd));
+	emit callbackReady(getBasicCommandReply(true, command, tan , isInstanceCmd));
 }
 
 void JsonAPI::sendSuccessDataReply(const QJsonValue &infoData, const JsonApiCommand& cmd)
@@ -1572,7 +1574,7 @@ void JsonAPI::sendSuccessDataReplyWithError(const QJsonValue &infoData, const QS
 		reply["errorData"] = errorsArray;
 	}
 
-	emit callbackMessage(reply);
+	emit callbackReady(reply);
 }
 
 void JsonAPI::sendErrorReply(const QString &error, const JsonApiCommand& cmd)
@@ -1601,7 +1603,7 @@ void JsonAPI::sendErrorReply(const QString &error, const QStringList& errorDetai
 		reply["errorData"] = errorsArray;
 	}
 
-	emit callbackMessage(reply);
+	emit callbackReady(reply);
 }
 
 void JsonAPI::sendNewRequest(const QJsonValue &infoData, const JsonApiCommand& cmd)
@@ -1621,7 +1623,7 @@ void JsonAPI::sendNewRequest(const QJsonValue &infoData, const QString &command,
 
 	request["info"] = infoData;
 
-	emit callbackMessage(request);
+	emit callbackReady(request);
 }
 
 void JsonAPI::sendNoAuthorization(const JsonApiCommand& cmd)
diff --git a/libsrc/api/JsonCallbacks.cpp b/libsrc/api/JsonCallbacks.cpp
@@ -282,22 +282,43 @@ QStringList JsonCallbacks::getSubscribedCommands() const
 }
 
 void JsonCallbacks::doCallback(Subscription::Type cmd, const QVariant& data)
+{
+	if (data.userType() == QMetaType::QJsonArray)
+	{
+		doCallback(cmd, data.toJsonArray());
+	}
+	else
+	{
+		doCallback(cmd, data.toJsonObject());
+	}
+}
+
+void JsonCallbacks::doCallback(Subscription::Type cmd, const QJsonArray& data)
 {
 	QJsonObject obj;
 	obj["command"] = Subscription::toString(cmd);
 
 	if (Subscription::isInstanceSpecific(cmd))
 	{
-		obj["instance"] = _hyperion->getInstanceIndex();
+		obj.insert("instance", _hyperion->getInstanceIndex());
 	}
+	obj.insert("data", data);
 
-	if (data.userType() == QMetaType::QJsonArray) {
-		obj["data"] = data.toJsonArray();
-	} else {
-		obj["data"] = data.toJsonObject();
+	emit callbackReady(obj);
+}
+
+void JsonCallbacks::doCallback(Subscription::Type cmd, const QJsonObject& data)
+{
+	QJsonObject obj;
+	obj["command"] = Subscription::toString(cmd);
+
+	if (Subscription::isInstanceSpecific(cmd))
+	{
+		obj.insert("instance", _hyperion->getInstanceIndex());
 	}
+	obj.insert("data", data);
 
-	emit newCallback(obj);
+	emit callbackReady(obj);
 }
 
 void JsonCallbacks::handleComponentState(hyperion::Components comp, bool state)
@@ -306,7 +327,7 @@ void JsonCallbacks::handleComponentState(hyperion::Components comp, bool state)
 	data["name"] = componentToIdString(comp);
 	data["enabled"] = state;
 
-	doCallback(Subscription::ComponentsUpdate, QVariant(data));
+	doCallback(Subscription::ComponentsUpdate, data);
 }
 
 void JsonCallbacks::handlePriorityUpdate(int currentPriority, const PriorityMuxer::InputsMap& activeInputs)
@@ -315,15 +336,15 @@ void JsonCallbacks::handlePriorityUpdate(int currentPriority, const PriorityMuxe
 	data["priorities"] = JsonInfo::getPrioritiestInfo(currentPriority, activeInputs);
 	data["priorities_autoselect"] = _hyperion->sourceAutoSelectEnabled();
 
-	doCallback(Subscription::PrioritiesUpdate, QVariant(data));
+	doCallback(Subscription::PrioritiesUpdate, data);
 }
 
 void JsonCallbacks::handleImageToLedsMappingChange(int mappingType)
 {
 	QJsonObject data;
 	data["imageToLedMappingType"] = ImageProcessor::mappingTypeToStr(mappingType);
 
-	doCallback(Subscription::ImageToLedMappingUpdate, QVariant(data));
+	doCallback(Subscription::ImageToLedMappingUpdate, data);
 }
 
 void JsonCallbacks::handleAdjustmentChange()
@@ -335,37 +356,37 @@ void JsonCallbacks::handleVideoModeChange(VideoMode mode)
 {
 	QJsonObject data;
 	data["videomode"] = QString(videoMode2String(mode));
-	doCallback(Subscription::VideomodeUpdate, QVariant(data));
+	doCallback(Subscription::VideomodeUpdate, data);
 }
 
 #if defined(ENABLE_EFFECTENGINE)
 void JsonCallbacks::handleEffectListChange()
 {
 	QJsonObject effects;
 	effects["effects"] = JsonInfo::getEffects(_hyperion);
-	doCallback(Subscription::EffectsUpdate, QVariant(effects));
+	doCallback(Subscription::EffectsUpdate, effects);
 }
 #endif
 
 void JsonCallbacks::handleSettingsChange(settings::type type, const QJsonDocument& data)
 {
-	QJsonObject dat;
+	QJsonObject obj;
 	if(data.isObject()) {
-		dat[typeToString(type)] = data.object();
+		obj[typeToString(type)] = data.object();
 	} else {
-		dat[typeToString(type)] = data.array();
+		obj[typeToString(type)] = data.array();
 	}
 
-	doCallback(Subscription::SettingsUpdate, QVariant(dat));
+	doCallback(Subscription::SettingsUpdate, obj);
 }
 
 void JsonCallbacks::handleLedsConfigChange(settings::type type, const QJsonDocument& data)
 {
 	if(type == settings::LEDS)
 	{
-		QJsonObject dat;
-		dat[typeToString(type)] = data.array();
-		doCallback(Subscription::LedsUpdate, QVariant(dat));
+		QJsonObject obj;
+		obj[typeToString(type)] = data.array();
+		doCallback(Subscription::LedsUpdate, obj);
 	}
 }
 
@@ -385,21 +406,24 @@ void JsonCallbacks::handleTokenChange(const QVector<AuthManager::AuthDefinition>
 		sub["last_use"] = entry.lastUse;
 		arr.push_back(sub);
 	}
-	doCallback(Subscription::TokenUpdate, QVariant(arr));
+	doCallback(Subscription::TokenUpdate, arr);
 }
 
 void JsonCallbacks::handleLedColorUpdate(const std::vector<ColorRgb> &ledColors)
 {
 	QJsonObject result;
 	QJsonArray leds;
 
-	for (const auto &color : ledColors)
+	// Avoid copying by appending RGB values directly
+	for (const auto& color : ledColors)
 	{
-		leds << QJsonValue(color.red) << QJsonValue(color.green) << QJsonValue(color.blue);
+		leds.append(QJsonValue(color.red));
+		leds.append(QJsonValue(color.green));
+		leds.append(QJsonValue(color.blue));
 	}
 	result["leds"] = leds;
 
-	doCallback(Subscription::LedColorsUpdate, QVariant(result));
+	doCallback(Subscription::LedColorsUpdate, result);
 }
 
 void JsonCallbacks::handleImageUpdate(const Image<ColorRgb> &image)
@@ -413,7 +437,7 @@ void JsonCallbacks::handleImageUpdate(const Image<ColorRgb> &image)
 	QJsonObject result;
 	result["image"] = "data:image/jpg;base64," + QString(byteArray.toBase64());
 
-	doCallback(Subscription::ImageUpdate, QVariant(result));
+	doCallback(Subscription::ImageUpdate, result);
 }
 
 void JsonCallbacks::handleLogMessageUpdate(const Logger::T_LOG_MESSAGE &msg)
@@ -445,7 +469,7 @@ void JsonCallbacks::handleLogMessageUpdate(const Logger::T_LOG_MESSAGE &msg)
 	}
 	result.insert("messages", messageArray);
 
-	doCallback(Subscription::LogMsgUpdate, QVariant(result));
+	doCallback(Subscription::LogMsgUpdate, result);
 }
 
 void JsonCallbacks::handleEventUpdate(const Event &event)
@@ -454,6 +478,6 @@ void JsonCallbacks::handleEventUpdate(const Event &event)
 
 	result["event"] = eventToString(event);
 
-	doCallback(Subscription::EventUpdate, QVariant(result));
+	doCallback(Subscription::EventUpdate, result);
 }
 
diff --git a/libsrc/jsonserver/JsonClientConnection.cpp b/libsrc/jsonserver/JsonClientConnection.cpp
@@ -1,6 +1,7 @@
 // project includes
 #include "JsonClientConnection.h"
 #include <api/JsonAPI.h>
+#include <api/JsonCallbacks.h>
 
 // qt inc
 #include <QTcpSocket>
@@ -17,8 +18,9 @@ JsonClientConnection::JsonClientConnection(QTcpSocket *socket, bool localConnect
 	// create a new instance of JsonAPI
 	_jsonAPI = new JsonAPI(socket->peerAddress().toString(), _log, localConnection, this);
 	// get the callback messages from JsonAPI and send it to the client
-	connect(_jsonAPI, &JsonAPI::callbackMessage, this , &JsonClientConnection::sendMessage);
+	connect(_jsonAPI, &JsonAPI::callbackReady, this , &JsonClientConnection::sendMessage);
 	connect(_jsonAPI, &JsonAPI::forceClose, this , [&](){ _socket->close(); } );
+	connect(_jsonAPI->getCallBack().get(), &JsonCallbacks::callbackReady, this, &JsonClientConnection::sendMessage);
 
 	_jsonAPI->initialize();
 }
@@ -47,7 +49,8 @@ void JsonClientConnection::readRequest()
 qint64 JsonClientConnection::sendMessage(QJsonObject message)
 {
 	QJsonDocument writer(message);
-	QByteArray data = writer.toJson(QJsonDocument::Compact) + "\n";
+	QByteArray data = writer.toJson(QJsonDocument::Compact);
+	data.append('\n');
 
 	if (!_socket || (_socket->state() != QAbstractSocket::ConnectedState)) return 0;
 	return _socket->write(data.data(), data.size());
diff --git a/libsrc/webserver/WebJsonRpc.cpp b/libsrc/webserver/WebJsonRpc.cpp
@@ -5,6 +5,7 @@
 #include "QtHttpClientWrapper.h"
 
 #include <api/JsonAPI.h>
+#include <api/JsonCallbacks.h>
 
 WebJsonRpc::WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, bool localConnection, QtHttpClientWrapper* parent)
 	: QObject(parent)
@@ -14,8 +15,10 @@ WebJsonRpc::WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, bool localC
 {
 	const QString client = request->getClientInfo().clientAddress.toString();
 	_jsonAPI = new JsonAPI(client, _log, localConnection, this, true);
-	connect(_jsonAPI, &JsonAPI::callbackMessage, this, &WebJsonRpc::handleCallback);
+	connect(_jsonAPI, &JsonAPI::callbackReady, this, &WebJsonRpc::sendCallbackMessage);
 	connect(_jsonAPI, &JsonAPI::forceClose, [&]() { _wrapper->closeConnection(); _stopHandle = true; });
+	connect(_jsonAPI->getCallBack().get(), &JsonCallbacks::callbackReady, this, &WebJsonRpc::sendCallbackMessage);
+
 	_jsonAPI->initialize();
 }
 
@@ -31,7 +34,7 @@ void WebJsonRpc::handleMessage(QtHttpRequest* request)
 	}
 }
 
-void WebJsonRpc::handleCallback(QJsonObject obj)
+void WebJsonRpc::sendCallbackMessage(QJsonObject obj)
 {
 	// guard against wrong callbacks; TODO: Remove when JSONAPI is more solid
 	if(!_unlocked) return;
diff --git a/libsrc/webserver/WebJsonRpc.h b/libsrc/webserver/WebJsonRpc.h
@@ -26,5 +26,5 @@ class WebJsonRpc : public QObject {
 	bool _unlocked = false;
 
 private slots:
-	void handleCallback(QJsonObject obj);
+	void sendCallbackMessage(QJsonObject obj);
 };
diff --git a/libsrc/webserver/WebSocketClient.cpp b/libsrc/webserver/WebSocketClient.cpp
@@ -4,6 +4,7 @@
 
 #include <hyperion/Hyperion.h>
 #include <api/JsonAPI.h>
+#include <api/JsonCallbacks.h>
 
 #include <QTcpSocket>
 #include <QtEndian>
@@ -24,9 +25,11 @@ WebSocketClient::WebSocketClient(QtHttpRequest* request, QTcpSocket* sock, bool
 
 	// Json processor
 	_jsonAPI.reset(new JsonAPI(client, _log, localConnection, this));
-	connect(_jsonAPI.get(), &JsonAPI::callbackMessage, this, &WebSocketClient::sendMessage);
+	connect(_jsonAPI.get(), &JsonAPI::callbackReady, this, &WebSocketClient::sendMessage);
 	connect(_jsonAPI.get(), &JsonAPI::forceClose, this,[this]() { this->sendClose(CLOSECODE::NORMAL); });
 
+	connect(_jsonAPI->getCallBack().get(), &JsonCallbacks::callbackReady, this, &WebSocketClient::sendMessage);
+
 	connect(this, &WebSocketClient::handleMessage, _jsonAPI.get(), &JsonAPI::handleMessage);
 
 	Debug(_log, "New connection from %s", QSTRING_CSTR(client));

Original file line number	Diff line number	Diff line change
`@@ -85,6 +85,11 @@ JsonAPI::JsonAPI(QString peerAddress, Logger *log, bool localConnection, QObject`
`85`	`85`	`_jsonCB = QSharedPointer<JsonCallbacks>(new JsonCallbacks( _log, _peerAddress, parent));`
`86`	`86`	`}`
`87`	`87`
	`88`	`+QSharedPointer<JsonCallbacks> JsonAPI::getCallBack() const`
	`89`	`+{`
	`90`	`+ return _jsonCB;`
	`91`	`+}`
	`92`	`+`
`88`	`93`	`void JsonAPI::initialize()`
`89`	`94`	`{`
`90`	`95`	`// init API, REQUIRED!`
`@@ -97,9 +102,6 @@ void JsonAPI::initialize()`
`97`	`102`	`// listen for killed instances`
`98`	`103`	`connect(_instanceManager, &HyperionIManager::instanceStateChanged, this, &JsonAPI::handleInstanceStateChange);`
`99`	`104`
`100`		`- // pipe callbacks from subscriptions to parent`
`101`		`- connect(_jsonCB.data(), &JsonCallbacks::newCallback, this, &JsonAPI::callbackMessage);`
`102`		`-`
`103`	`105`	`// notify hyperion about a jsonMessageForward`
`104`	`106`	`if (_hyperion != nullptr)`
`105`	`107`	`{`
`@@ -1537,7 +1539,7 @@ void JsonAPI::sendSuccessReply(const JsonApiCommand& cmd)`
`1537`	`1539`
`1538`	`1540`	`void JsonAPI::sendSuccessReply(const QString &command, int tan, InstanceCmd::Type isInstanceCmd)`
`1539`	`1541`	`{`
`1540`		`- emit callbackMessage(getBasicCommandReply(true, command, tan , isInstanceCmd));`
	`1542`	`+ emit callbackReady(getBasicCommandReply(true, command, tan , isInstanceCmd));`
`1541`	`1543`	`}`
`1542`	`1544`
`1543`	`1545`	`void JsonAPI::sendSuccessDataReply(const QJsonValue &infoData, const JsonApiCommand& cmd)`
`@@ -1572,7 +1574,7 @@ void JsonAPI::sendSuccessDataReplyWithError(const QJsonValue &infoData, const QS`
`1572`	`1574`	`reply["errorData"] = errorsArray;`
`1573`	`1575`	`}`
`1574`	`1576`
`1575`		`- emit callbackMessage(reply);`
	`1577`	`+ emit callbackReady(reply);`
`1576`	`1578`	`}`
`1577`	`1579`
`1578`	`1580`	`void JsonAPI::sendErrorReply(const QString &error, const JsonApiCommand& cmd)`
`@@ -1601,7 +1603,7 @@ void JsonAPI::sendErrorReply(const QString &error, const QStringList& errorDetai`
`1601`	`1603`	`reply["errorData"] = errorsArray;`
`1602`	`1604`	`}`
`1603`	`1605`
`1604`		`- emit callbackMessage(reply);`
	`1606`	`+ emit callbackReady(reply);`
`1605`	`1607`	`}`
`1606`	`1608`
`1607`	`1609`	`void JsonAPI::sendNewRequest(const QJsonValue &infoData, const JsonApiCommand& cmd)`
`@@ -1621,7 +1623,7 @@ void JsonAPI::sendNewRequest(const QJsonValue &infoData, const QString &command,`
`1621`	`1623`
`1622`	`1624`	`request["info"] = infoData;`
`1623`	`1625`
`1624`		`- emit callbackMessage(request);`
	`1626`	`+ emit callbackReady(request);`
`1625`	`1627`	`}`
`1626`	`1628`
`1627`	`1629`	`void JsonAPI::sendNoAuthorization(const JsonApiCommand& cmd)`
Original file line number	Diff line number	Diff line change
`@@ -282,22 +282,43 @@ QStringList JsonCallbacks::getSubscribedCommands() const`
`282`	`282`	`}`
`283`	`283`
`284`	`284`	`void JsonCallbacks::doCallback(Subscription::Type cmd, const QVariant& data)`
	`285`	`+{`
	`286`	`+ if (data.userType() == QMetaType::QJsonArray)`
	`287`	`+ {`
	`288`	`+ doCallback(cmd, data.toJsonArray());`
	`289`	`+ }`
	`290`	`+ else`
	`291`	`+ {`
	`292`	`+ doCallback(cmd, data.toJsonObject());`
	`293`	`+ }`
	`294`	`+}`
	`295`	`+`
	`296`	`+void JsonCallbacks::doCallback(Subscription::Type cmd, const QJsonArray& data)`
`285`	`297`	`{`
`286`	`298`	`QJsonObject obj;`
`287`	`299`	`obj["command"] = Subscription::toString(cmd);`
`288`	`300`
`289`	`301`	`if (Subscription::isInstanceSpecific(cmd))`
`290`	`302`	`{`
`291`		`- obj["instance"] = _hyperion->getInstanceIndex();`
	`303`	`+ obj.insert("instance", _hyperion->getInstanceIndex());`
`292`	`304`	`}`
	`305`	`+ obj.insert("data", data);`
`293`	`306`
`294`		`- if (data.userType() == QMetaType::QJsonArray) {`
`295`		`- obj["data"] = data.toJsonArray();`
`296`		`- } else {`
`297`		`- obj["data"] = data.toJsonObject();`
	`307`	`+ emit callbackReady(obj);`
	`308`	`+}`
	`309`	`+`
	`310`	`+void JsonCallbacks::doCallback(Subscription::Type cmd, const QJsonObject& data)`
	`311`	`+{`
	`312`	`+ QJsonObject obj;`
	`313`	`+ obj["command"] = Subscription::toString(cmd);`
	`314`	`+`
	`315`	`+ if (Subscription::isInstanceSpecific(cmd))`
	`316`	`+ {`
	`317`	`+ obj.insert("instance", _hyperion->getInstanceIndex());`
`298`	`318`	`}`
	`319`	`+ obj.insert("data", data);`
`299`	`320`
`300`		`- emit newCallback(obj);`
	`321`	`+ emit callbackReady(obj);`
`301`	`322`	`}`
`302`	`323`
`303`	`324`	`void JsonCallbacks::handleComponentState(hyperion::Components comp, bool state)`
`@@ -306,7 +327,7 @@ void JsonCallbacks::handleComponentState(hyperion::Components comp, bool state)`
`306`	`327`	`data["name"] = componentToIdString(comp);`
`307`	`328`	`data["enabled"] = state;`
`308`	`329`
`309`		`- doCallback(Subscription::ComponentsUpdate, QVariant(data));`
	`330`	`+ doCallback(Subscription::ComponentsUpdate, data);`
`310`	`331`	`}`
`311`	`332`
`312`	`333`	`void JsonCallbacks::handlePriorityUpdate(int currentPriority, const PriorityMuxer::InputsMap& activeInputs)`
`@@ -315,15 +336,15 @@ void JsonCallbacks::handlePriorityUpdate(int currentPriority, const PriorityMuxe`
`315`	`336`	`data["priorities"] = JsonInfo::getPrioritiestInfo(currentPriority, activeInputs);`
`316`	`337`	`data["priorities_autoselect"] = _hyperion->sourceAutoSelectEnabled();`
`317`	`338`
`318`		`- doCallback(Subscription::PrioritiesUpdate, QVariant(data));`
	`339`	`+ doCallback(Subscription::PrioritiesUpdate, data);`
`319`	`340`	`}`
`320`	`341`
`321`	`342`	`void JsonCallbacks::handleImageToLedsMappingChange(int mappingType)`
`322`	`343`	`{`
`323`	`344`	`QJsonObject data;`
`324`	`345`	`data["imageToLedMappingType"] = ImageProcessor::mappingTypeToStr(mappingType);`
`325`	`346`
`326`		`- doCallback(Subscription::ImageToLedMappingUpdate, QVariant(data));`
	`347`	`+ doCallback(Subscription::ImageToLedMappingUpdate, data);`
`327`	`348`	`}`
`328`	`349`
`329`	`350`	`void JsonCallbacks::handleAdjustmentChange()`
`@@ -335,37 +356,37 @@ void JsonCallbacks::handleVideoModeChange(VideoMode mode)`
`335`	`356`	`{`
`336`	`357`	`QJsonObject data;`
`337`	`358`	`data["videomode"] = QString(videoMode2String(mode));`
`338`		`- doCallback(Subscription::VideomodeUpdate, QVariant(data));`
	`359`	`+ doCallback(Subscription::VideomodeUpdate, data);`
`339`	`360`	`}`
`340`	`361`
`341`	`362`	`#if defined(ENABLE_EFFECTENGINE)`
`342`	`363`	`void JsonCallbacks::handleEffectListChange()`
`343`	`364`	`{`
`344`	`365`	`QJsonObject effects;`
`345`	`366`	`effects["effects"] = JsonInfo::getEffects(_hyperion);`
`346`		`- doCallback(Subscription::EffectsUpdate, QVariant(effects));`
	`367`	`+ doCallback(Subscription::EffectsUpdate, effects);`
`347`	`368`	`}`
`348`	`369`	`#endif`
`349`	`370`
`350`	`371`	`void JsonCallbacks::handleSettingsChange(settings::type type, const QJsonDocument& data)`
`351`	`372`	`{`
`352`		`- QJsonObject dat;`
	`373`	`+ QJsonObject obj;`
`353`	`374`	`if(data.isObject()) {`
`354`		`- dat[typeToString(type)] = data.object();`
	`375`	`+ obj[typeToString(type)] = data.object();`
`355`	`376`	`} else {`
`356`		`- dat[typeToString(type)] = data.array();`
	`377`	`+ obj[typeToString(type)] = data.array();`
`357`	`378`	`}`
`358`	`379`
`359`		`- doCallback(Subscription::SettingsUpdate, QVariant(dat));`
	`380`	`+ doCallback(Subscription::SettingsUpdate, obj);`
`360`	`381`	`}`
`361`	`382`
`362`	`383`	`void JsonCallbacks::handleLedsConfigChange(settings::type type, const QJsonDocument& data)`
`363`	`384`	`{`
`364`	`385`	`if(type == settings::LEDS)`
`365`	`386`	`{`
`366`		`- QJsonObject dat;`
`367`		`- dat[typeToString(type)] = data.array();`
`368`		`- doCallback(Subscription::LedsUpdate, QVariant(dat));`
	`387`	`+ QJsonObject obj;`
	`388`	`+ obj[typeToString(type)] = data.array();`
	`389`	`+ doCallback(Subscription::LedsUpdate, obj);`
`369`	`390`	`}`
`370`	`391`	`}`
`371`	`392`
`@@ -385,21 +406,24 @@ void JsonCallbacks::handleTokenChange(const QVector<AuthManager::AuthDefinition>`
`385`	`406`	`sub["last_use"] = entry.lastUse;`
`386`	`407`	`arr.push_back(sub);`
`387`	`408`	`}`
`388`		`- doCallback(Subscription::TokenUpdate, QVariant(arr));`
	`409`	`+ doCallback(Subscription::TokenUpdate, arr);`
`389`	`410`	`}`
`390`	`411`
`391`	`412`	`void JsonCallbacks::handleLedColorUpdate(const std::vector<ColorRgb> &ledColors)`
`392`	`413`	`{`
`393`	`414`	`QJsonObject result;`
`394`	`415`	`QJsonArray leds;`
`395`	`416`
`396`		`- for (const auto &color : ledColors)`
	`417`	`+ // Avoid copying by appending RGB values directly`
	`418`	`+ for (const auto& color : ledColors)`
`397`	`419`	`{`
`398`		`- leds << QJsonValue(color.red) << QJsonValue(color.green) << QJsonValue(color.blue);`
	`420`	`+ leds.append(QJsonValue(color.red));`
	`421`	`+ leds.append(QJsonValue(color.green));`
	`422`	`+ leds.append(QJsonValue(color.blue));`
`399`	`423`	`}`
`400`	`424`	`result["leds"] = leds;`
`401`	`425`
`402`		`- doCallback(Subscription::LedColorsUpdate, QVariant(result));`
	`426`	`+ doCallback(Subscription::LedColorsUpdate, result);`
`403`	`427`	`}`
`404`	`428`
`405`	`429`	`void JsonCallbacks::handleImageUpdate(const Image<ColorRgb> &image)`
`@@ -413,7 +437,7 @@ void JsonCallbacks::handleImageUpdate(const Image<ColorRgb> &image)`
`413`	`437`	`QJsonObject result;`
`414`	`438`	`result["image"] = "data:image/jpg;base64," + QString(byteArray.toBase64());`
`415`	`439`
`416`		`- doCallback(Subscription::ImageUpdate, QVariant(result));`
	`440`	`+ doCallback(Subscription::ImageUpdate, result);`
`417`	`441`	`}`
`418`	`442`
`419`	`443`	`void JsonCallbacks::handleLogMessageUpdate(const Logger::T_LOG_MESSAGE &msg)`
`@@ -445,7 +469,7 @@ void JsonCallbacks::handleLogMessageUpdate(const Logger::T_LOG_MESSAGE &msg)`
`445`	`469`	`}`
`446`	`470`	`result.insert("messages", messageArray);`
`447`	`471`
`448`		`- doCallback(Subscription::LogMsgUpdate, QVariant(result));`
	`472`	`+ doCallback(Subscription::LogMsgUpdate, result);`
`449`	`473`	`}`
`450`	`474`
`451`	`475`	`void JsonCallbacks::handleEventUpdate(const Event &event)`
`@@ -454,6 +478,6 @@ void JsonCallbacks::handleEventUpdate(const Event &event)`
`454`	`478`
`455`	`479`	`result["event"] = eventToString(event);`
`456`	`480`
`457`		`- doCallback(Subscription::EventUpdate, QVariant(result));`
	`481`	`+ doCallback(Subscription::EventUpdate, result);`
`458`	`482`	`}`
`459`	`483`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`#include "QtHttpClientWrapper.h"`
`6`	`6`
`7`	`7`	`#include <api/JsonAPI.h>`
	`8`	`+#include <api/JsonCallbacks.h>`
`8`	`9`
`9`	`10`	`WebJsonRpc::WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, bool localConnection, QtHttpClientWrapper* parent)`
`10`	`11`	`: QObject(parent)`
`@@ -14,8 +15,10 @@ WebJsonRpc::WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, bool localC`
`14`	`15`	`{`
`15`	`16`	`const QString client = request->getClientInfo().clientAddress.toString();`
`16`	`17`	`_jsonAPI = new JsonAPI(client, _log, localConnection, this, true);`
`17`		`- connect(_jsonAPI, &JsonAPI::callbackMessage, this, &WebJsonRpc::handleCallback);`
	`18`	`+ connect(_jsonAPI, &JsonAPI::callbackReady, this, &WebJsonRpc::sendCallbackMessage);`
`18`	`19`	`connect(_jsonAPI, &JsonAPI::forceClose, [&]() { _wrapper->closeConnection(); _stopHandle = true; });`
	`20`	`+ connect(_jsonAPI->getCallBack().get(), &JsonCallbacks::callbackReady, this, &WebJsonRpc::sendCallbackMessage);`
	`21`	`+`
`19`	`22`	`_jsonAPI->initialize();`
`20`	`23`	`}`
`21`	`24`
`@@ -31,7 +34,7 @@ void WebJsonRpc::handleMessage(QtHttpRequest* request)`
`31`	`34`	`}`
`32`	`35`	`}`
`33`	`36`
`34`		`-void WebJsonRpc::handleCallback(QJsonObject obj)`
	`37`	`+void WebJsonRpc::sendCallbackMessage(QJsonObject obj)`
`35`	`38`	`{`
`36`	`39`	`// guard against wrong callbacks; TODO: Remove when JSONAPI is more solid`
`37`	`40`	`if(!_unlocked) return;`