1478 lines
43 KiB
C++
1478 lines
43 KiB
C++
// system includes
|
|
#include <stdexcept>
|
|
#include <cassert>
|
|
#include <iomanip>
|
|
#include <unistd.h>
|
|
|
|
// stl includes
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <iterator>
|
|
|
|
// Qt includes
|
|
#include <QResource>
|
|
#include <QDateTime>
|
|
#include <QCryptographicHash>
|
|
#include <QHostInfo>
|
|
#include <QString>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QCoreApplication>
|
|
#include <QJsonObject>
|
|
#include <QJsonDocument>
|
|
#include <QVariantMap>
|
|
#include <QDir>
|
|
|
|
// hyperion util includes
|
|
#include <hyperion/ImageProcessorFactory.h>
|
|
#include <hyperion/ImageProcessor.h>
|
|
#include <hyperion/MessageForwarder.h>
|
|
#include <hyperion/ColorTransform.h>
|
|
#include <hyperion/ColorAdjustment.h>
|
|
#include <utils/ColorRgb.h>
|
|
#include <leddevice/LedDevice.h>
|
|
#include <HyperionConfig.h>
|
|
#include <utils/jsonschema/QJsonFactory.h>
|
|
#include <utils/Process.h>
|
|
|
|
// project includes
|
|
#include "JsonClientConnection.h"
|
|
|
|
using namespace hyperion;
|
|
|
|
JsonClientConnection::JsonClientConnection(QTcpSocket *socket)
|
|
: QObject()
|
|
, _socket(socket)
|
|
, _imageProcessor(ImageProcessorFactory::getInstance().newImageProcessor())
|
|
, _hyperion(Hyperion::getInstance())
|
|
, _receiveBuffer()
|
|
, _webSocketHandshakeDone(false)
|
|
, _log(Logger::getInstance("JSONCLIENTCONNECTION"))
|
|
, _forwarder_enabled(true)
|
|
, _streaming_logging_activated(false)
|
|
{
|
|
// connect internal signals and slots
|
|
connect(_socket, SIGNAL(disconnected()), this, SLOT(socketClosed()));
|
|
connect(_socket, SIGNAL(readyRead()), this, SLOT(readData()));
|
|
connect(_hyperion, SIGNAL(componentStateChanged(hyperion::Components,bool)), this, SLOT(componentStateChanged(hyperion::Components,bool)));
|
|
|
|
_timer_ledcolors.setSingleShot(false);
|
|
connect(&_timer_ledcolors, SIGNAL(timeout()), this, SLOT(streamLedcolorsUpdate()));
|
|
}
|
|
|
|
|
|
JsonClientConnection::~JsonClientConnection()
|
|
{
|
|
delete _socket;
|
|
}
|
|
|
|
void JsonClientConnection::readData()
|
|
{
|
|
_receiveBuffer += _socket->readAll();
|
|
|
|
if (_webSocketHandshakeDone)
|
|
{
|
|
// websocket mode, data frame
|
|
handleWebSocketFrame();
|
|
}
|
|
else
|
|
{
|
|
// might be a handshake request or raw socket data
|
|
if(_receiveBuffer.contains("Upgrade: websocket"))
|
|
{
|
|
doWebSocketHandshake();
|
|
} else
|
|
{
|
|
// raw socket data, handling as usual
|
|
int bytes = _receiveBuffer.indexOf('\n') + 1;
|
|
while(bytes > 0)
|
|
{
|
|
// create message string
|
|
std::string message(_receiveBuffer.data(), bytes);
|
|
|
|
// remove message data from buffer
|
|
_receiveBuffer = _receiveBuffer.mid(bytes);
|
|
|
|
// handle message
|
|
handleMessage(QString::fromStdString(message));
|
|
|
|
// try too look up '\n' again
|
|
bytes = _receiveBuffer.indexOf('\n') + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::handleWebSocketFrame()
|
|
{
|
|
if ((_receiveBuffer.at(0) & BHB0_FIN) == BHB0_FIN)
|
|
{
|
|
// final bit found, frame complete
|
|
quint8 * maskKey = NULL;
|
|
quint8 opCode = _receiveBuffer.at(0) & BHB0_OPCODE;
|
|
bool isMasked = (_receiveBuffer.at(1) & BHB0_FIN) == BHB0_FIN;
|
|
quint64 payloadLength = _receiveBuffer.at(1) & BHB1_PAYLOAD;
|
|
quint32 index = 2;
|
|
|
|
switch (payloadLength)
|
|
{
|
|
case payload_size_code_16bit:
|
|
payloadLength = ((_receiveBuffer.at(2) << 8) & 0xFF00) | (_receiveBuffer.at(3) & 0xFF);
|
|
index += 2;
|
|
break;
|
|
case payload_size_code_64bit:
|
|
payloadLength = 0;
|
|
for (uint i=0; i < 8; i++)
|
|
{
|
|
payloadLength |= ((quint64)(_receiveBuffer.at(index+i) & 0xFF)) << (8*(7-i));
|
|
}
|
|
index += 8;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (isMasked)
|
|
{
|
|
// if the data is masked we need to get the key for unmasking
|
|
maskKey = new quint8[4];
|
|
for (uint i=0; i < 4; i++)
|
|
{
|
|
maskKey[i] = _receiveBuffer.at(index + i);
|
|
}
|
|
index += 4;
|
|
}
|
|
|
|
// check the type of data frame
|
|
switch (opCode)
|
|
{
|
|
case OPCODE::TEXT:
|
|
{
|
|
// frame contains text, extract it
|
|
QByteArray result = _receiveBuffer.mid(index, payloadLength);
|
|
_receiveBuffer.clear();
|
|
|
|
// unmask data if necessary
|
|
if (isMasked)
|
|
{
|
|
for (uint i=0; i < payloadLength; i++)
|
|
{
|
|
result[i] = (result[i] ^ maskKey[i % 4]);
|
|
}
|
|
if (maskKey != NULL)
|
|
{
|
|
delete[] maskKey;
|
|
maskKey = NULL;
|
|
}
|
|
}
|
|
|
|
handleMessage(QString(result));
|
|
}
|
|
break;
|
|
case OPCODE::CLOSE:
|
|
{
|
|
// close request, confirm
|
|
quint8 close[] = {0x88, 0};
|
|
_socket->write((const char*)close, 2);
|
|
_socket->flush();
|
|
_socket->close();
|
|
}
|
|
break;
|
|
case OPCODE::PING:
|
|
{
|
|
// ping received, send pong
|
|
quint8 pong[] = {OPCODE::PONG, 0};
|
|
_socket->write((const char*)pong, 2);
|
|
_socket->flush();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Error(_log, "Someone is sending very big messages over several frames... it's not supported yet");
|
|
quint8 close[] = {0x88, 0};
|
|
_socket->write((const char*)close, 2);
|
|
_socket->flush();
|
|
_socket->close();
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::doWebSocketHandshake()
|
|
{
|
|
// http header, might not be a very reliable check...
|
|
Debug(_log, "Websocket handshake");
|
|
|
|
// get the key to prepare an answer
|
|
int start = _receiveBuffer.indexOf("Sec-WebSocket-Key") + 19;
|
|
std::string value(_receiveBuffer.mid(start, _receiveBuffer.indexOf("\r\n", start) - start).data());
|
|
_receiveBuffer.clear();
|
|
|
|
// must be always appended
|
|
value += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
|
|
|
|
// generate sha1 hash
|
|
QByteArray hash = QCryptographicHash::hash(value.c_str(), QCryptographicHash::Sha1);
|
|
|
|
// prepare an answer
|
|
std::ostringstream h;
|
|
h << "HTTP/1.1 101 Switching Protocols\r\n" <<
|
|
"Upgrade: websocket\r\n" <<
|
|
"Connection: Upgrade\r\n" <<
|
|
"Sec-WebSocket-Accept: " << QString(hash.toBase64()).toStdString() << "\r\n\r\n";
|
|
|
|
_socket->write(h.str().c_str());
|
|
_socket->flush();
|
|
// we are in WebSocket mode, data frames should follow next
|
|
_webSocketHandshakeDone = true;
|
|
}
|
|
|
|
void JsonClientConnection::socketClosed()
|
|
{
|
|
_webSocketHandshakeDone = false;
|
|
emit connectionClosed(this);
|
|
}
|
|
|
|
void JsonClientConnection::handleMessage(const QString& messageString)
|
|
{
|
|
QString errors;
|
|
|
|
try
|
|
{
|
|
QJsonParseError error;
|
|
QJsonDocument doc = QJsonDocument::fromJson(messageString.toUtf8(), &error);
|
|
|
|
if (error.error != QJsonParseError::NoError)
|
|
{
|
|
// report to the user the failure and their locations in the document.
|
|
int errorLine(0), errorColumn(0);
|
|
|
|
for( int i=0, count=qMin( error.offset,messageString.size()); i<count; ++i )
|
|
{
|
|
++errorColumn;
|
|
if(messageString.at(i) == '\n' )
|
|
{
|
|
errorColumn = 0;
|
|
++errorLine;
|
|
}
|
|
}
|
|
|
|
std::stringstream sstream;
|
|
sstream << "Error while parsing json: " << error.errorString().toStdString() << " at Line: " << errorLine << ", Column: " << errorColumn;
|
|
sendErrorReply(QString::fromStdString(sstream.str()));
|
|
return;
|
|
}
|
|
|
|
const QJsonObject message = doc.object();
|
|
|
|
// check basic message
|
|
if (!checkJson(message, ":schema", errors))
|
|
{
|
|
sendErrorReply("Error while validating json: " + errors);
|
|
return;
|
|
}
|
|
|
|
// check specific message
|
|
const QString command = message["command"].toString();
|
|
if (!checkJson(message, QString(":schema-%1").arg(command), errors))
|
|
{
|
|
sendErrorReply("Error while validating json: " + errors);
|
|
return;
|
|
}
|
|
|
|
int tan = message["tan"].toInt(0);
|
|
// switch over all possible commands and handle them
|
|
if (command == "color")
|
|
handleColorCommand(message, command, tan);
|
|
else if (command == "image")
|
|
handleImageCommand(message, command, tan);
|
|
else if (command == "effect")
|
|
handleEffectCommand(message, command, tan);
|
|
else if (command == "create-effect")
|
|
handleCreateEffectCommand(message, command, tan);
|
|
else if (command == "delete-effect")
|
|
handleDeleteEffectCommand(message, command, tan);
|
|
else if (command == "serverinfo")
|
|
handleServerInfoCommand(message, command, tan);
|
|
else if (command == "clear")
|
|
handleClearCommand(message, command, tan);
|
|
else if (command == "clearall")
|
|
handleClearallCommand(message, command, tan);
|
|
else if (command == "transform")
|
|
handleTransformCommand(message, command, tan);
|
|
else if (command == "adjustment")
|
|
handleAdjustmentCommand(message, command, tan);
|
|
else if (command == "sourceselect")
|
|
handleSourceSelectCommand(message, command, tan);
|
|
else if (command == "config")
|
|
handleConfigCommand(message, command, tan);
|
|
else if (command == "componentstate")
|
|
handleComponentStateCommand(message, command, tan);
|
|
else if (command == "ledcolors")
|
|
handleLedColorsCommand(message, command, tan);
|
|
else if (command == "logging")
|
|
handleLoggingCommand(message, command, tan);
|
|
else
|
|
handleNotImplemented();
|
|
}
|
|
catch (std::exception& e)
|
|
{
|
|
sendErrorReply("Error while processing incoming json message: " + QString(e.what()) + " " + errors );
|
|
Warning(_log, "Error while processing incoming json message: %s (%s)", e.what(), errors.toStdString().c_str());
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::componentStateChanged(const hyperion::Components component, bool enable)
|
|
{
|
|
if (component == COMP_FORWARDER && _forwarder_enabled != enable)
|
|
{
|
|
_forwarder_enabled = enable;
|
|
Info(_log, "forwarder change state to %s", (enable ? "enabled" : "disabled") );
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::forwardJsonMessage(const QJsonObject & message)
|
|
{
|
|
if (_forwarder_enabled)
|
|
{
|
|
QTcpSocket client;
|
|
QList<MessageForwarder::JsonSlaveAddress> list = _hyperion->getForwarder()->getJsonSlaves();
|
|
|
|
for ( int i=0; i<list.size(); i++ )
|
|
{
|
|
client.connectToHost(list.at(i).addr, list.at(i).port);
|
|
if ( client.waitForConnected(500) )
|
|
{
|
|
sendMessage(message,&client);
|
|
client.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::handleColorCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
forwardJsonMessage(message);
|
|
|
|
// extract parameters
|
|
int priority = message["priority"].toInt();
|
|
int duration = message["duration"].toInt(-1);
|
|
|
|
std::vector<ColorRgb> colorData(_hyperion->getLedCount());
|
|
const QJsonArray & jsonColor = message["color"].toArray();
|
|
unsigned int i = 0;
|
|
for (; i < unsigned(jsonColor.size()/3) && i < _hyperion->getLedCount(); ++i)
|
|
{
|
|
colorData[i].red = uint8_t(jsonColor.at(3u*i).toInt());
|
|
colorData[i].green = uint8_t(jsonColor.at(3u*i+1u).toInt());
|
|
colorData[i].blue = uint8_t(jsonColor.at(3u*i+2u).toInt());
|
|
}
|
|
|
|
// copy full blocks of led colors
|
|
unsigned size = i;
|
|
while (i + size < _hyperion->getLedCount())
|
|
{
|
|
memcpy(&(colorData[i]), colorData.data(), size * sizeof(ColorRgb));
|
|
i += size;
|
|
}
|
|
|
|
// copy remaining block of led colors
|
|
if (i < _hyperion->getLedCount())
|
|
{
|
|
memcpy(&(colorData[i]), colorData.data(), (_hyperion->getLedCount()-i) * sizeof(ColorRgb));
|
|
}
|
|
|
|
// set output
|
|
_hyperion->setColors(priority, colorData, duration);
|
|
|
|
// send reply
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleImageCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
forwardJsonMessage(message);
|
|
|
|
// extract parameters
|
|
int priority = message["priority"].toInt();
|
|
int duration = message["duration"].toInt(-1);
|
|
int width = message["imagewidth"].toInt();
|
|
int height = message["imageheight"].toInt();
|
|
QByteArray data = QByteArray::fromBase64(QByteArray(message["imagedata"].toString().toUtf8()));
|
|
|
|
// check consistency of the size of the received data
|
|
if (data.size() != width*height*3)
|
|
{
|
|
sendErrorReply("Size of image data does not match with the width and height", command, tan);
|
|
return;
|
|
}
|
|
|
|
// set width and height of the image processor
|
|
_imageProcessor->setSize(width, height);
|
|
|
|
// create ImageRgb
|
|
Image<ColorRgb> image(width, height);
|
|
memcpy(image.memptr(), data.data(), data.size());
|
|
|
|
// process the image
|
|
std::vector<ColorRgb> ledColors = _imageProcessor->process(image);
|
|
_hyperion->setColors(priority, ledColors, duration);
|
|
|
|
// send reply
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleEffectCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
forwardJsonMessage(message);
|
|
|
|
// extract parameters
|
|
int priority = message["priority"].toInt();
|
|
int duration = message["duration"].toInt(-1);
|
|
QString pythonScript = message["pythonScript"].toString("");
|
|
const QJsonObject & effect = message["effect"].toObject();
|
|
const QString & effectName = effect["name"].toString();
|
|
|
|
// set output
|
|
if (effect.contains("args"))
|
|
{
|
|
_hyperion->setEffect(effectName, effect["args"].toObject(), priority, duration, pythonScript);
|
|
}
|
|
else
|
|
{
|
|
_hyperion->setEffect(effectName, priority, duration);
|
|
}
|
|
|
|
// send reply
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleCreateEffectCommand(const QJsonObject& message, const QString &command, const int tan)
|
|
{
|
|
struct find_schema: std::unary_function<EffectSchema, bool>
|
|
{
|
|
QString pyFile;
|
|
find_schema(QString pyFile):pyFile(pyFile) { }
|
|
bool operator()(EffectSchema const& schema) const
|
|
{
|
|
return schema.pyFile == pyFile;
|
|
}
|
|
};
|
|
|
|
if(message.size() > 0)
|
|
{
|
|
if (!message["args"].toObject().isEmpty())
|
|
{
|
|
QString scriptName;
|
|
(message["script"].toString().mid(0, 1) == ":" )
|
|
? scriptName = ":/effects//" + message["script"].toString().mid(1)
|
|
: scriptName = message["script"].toString();
|
|
|
|
std::list<EffectSchema> effectsSchemas = _hyperion->getEffectSchemas();
|
|
std::list<EffectSchema>::iterator it = std::find_if(effectsSchemas.begin(), effectsSchemas.end(), find_schema(scriptName));
|
|
|
|
if (it != effectsSchemas.end())
|
|
{
|
|
QString errors;
|
|
|
|
if (!checkJson(message["args"].toObject(), it->schemaFile, errors))
|
|
{
|
|
sendErrorReply("Error while validating json: " + errors, command, tan);
|
|
return;
|
|
}
|
|
|
|
QJsonObject effectJson;
|
|
QJsonArray effectArray;
|
|
effectArray = _hyperion->getQJsonConfig()["effects"].toObject()["paths"].toArray();
|
|
|
|
if (effectArray.size() > 0)
|
|
{
|
|
if (message["name"].toString().trimmed().isEmpty())
|
|
{
|
|
sendErrorReply("Can't save new effect. Effect name is empty", command, tan);
|
|
return;
|
|
}
|
|
|
|
effectJson["name"] = message["name"].toString();
|
|
effectJson["script"] = message["script"].toString();
|
|
effectJson["args"] = message["args"].toObject();
|
|
|
|
QFileInfo newFileName(effectArray[0].toString() + QDir::separator() + message["name"].toString().replace(QString(" "), QString("")) + QString(".json"));
|
|
|
|
while(newFileName.exists())
|
|
{
|
|
newFileName.setFile(effectArray[0].toString() + QDir::separator() + newFileName.baseName() + QString::number(qrand() % ((10) - 0) + 0) + QString(".json"));
|
|
}
|
|
|
|
QJsonFactory::writeJson(newFileName.absoluteFilePath(), effectJson);
|
|
Info(_log, "Reload effect list");
|
|
_hyperion->reloadEffects();
|
|
sendSuccessReply(command, tan);
|
|
} else
|
|
{
|
|
sendErrorReply("Can't save new effect. Effect path empty", command, tan);
|
|
return;
|
|
}
|
|
} else
|
|
sendErrorReply("Missing schema file for Python script " + message["script"].toString(), command, tan);
|
|
} else
|
|
sendErrorReply("Missing or empty Object 'args'", command, tan);
|
|
} else
|
|
sendErrorReply("Error while parsing json: Message size " + QString(message.size()), command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleDeleteEffectCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
struct find_effect: std::unary_function<EffectDefinition, bool>
|
|
{
|
|
QString effectName;
|
|
find_effect(QString effectName) :effectName(effectName) { }
|
|
bool operator()(EffectDefinition const& effectDefinition) const
|
|
{
|
|
return effectDefinition.name == effectName;
|
|
}
|
|
};
|
|
|
|
if(message.size() > 0)
|
|
{
|
|
QString effectName = message["name"].toString();
|
|
std::list<EffectDefinition> effectsDefinition = _hyperion->getEffects();
|
|
std::list<EffectDefinition>::iterator it = std::find_if(effectsDefinition.begin(), effectsDefinition.end(), find_effect(effectName));
|
|
|
|
if (it != effectsDefinition.end())
|
|
{
|
|
QFileInfo effectConfigurationFile(it->file);
|
|
if (effectConfigurationFile.absoluteFilePath().mid(0, 1) != ":" )
|
|
{
|
|
if (effectConfigurationFile.exists())
|
|
{
|
|
bool result = QFile::remove(effectConfigurationFile.absoluteFilePath());
|
|
if (result)
|
|
{
|
|
Info(_log, "Reload effect list");
|
|
_hyperion->reloadEffects();
|
|
sendSuccessReply(command, tan);
|
|
} else
|
|
sendErrorReply("Can't delete effect configuration file: " + effectConfigurationFile.absoluteFilePath() + ". Please check permissions", command, tan);
|
|
} else
|
|
sendErrorReply("Can't find effect configuration file: " + effectConfigurationFile.absoluteFilePath(), command, tan);
|
|
} else
|
|
sendErrorReply("Can't delete internal effect: " + message["name"].toString(), command, tan);
|
|
} else
|
|
sendErrorReply("Effect " + message["name"].toString() + " not found", command, tan);
|
|
} else
|
|
sendErrorReply("Error while parsing json: Message size " + QString(message.size()), command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleServerInfoCommand(const QJsonObject&, const QString& command, const int tan)
|
|
{
|
|
// create result
|
|
QJsonObject result;
|
|
result["success"] = true;
|
|
result["command"] = command;
|
|
result["tan"] = tan;
|
|
|
|
QJsonObject info;
|
|
|
|
// add host name for remote clients
|
|
info["hostname"] = QHostInfo::localHostName();
|
|
|
|
// collect priority information
|
|
QJsonArray priorities;
|
|
uint64_t now = QDateTime::currentMSecsSinceEpoch();
|
|
QList<int> activePriorities = _hyperion->getActivePriorities();
|
|
Hyperion::PriorityRegister priorityRegister = _hyperion->getPriorityRegister();
|
|
int currentPriority = _hyperion->getCurrentPriority();
|
|
|
|
foreach (int priority, activePriorities) {
|
|
const Hyperion::InputInfo & priorityInfo = _hyperion->getPriorityInfo(priority);
|
|
QJsonObject item;
|
|
item["priority"] = priority;
|
|
if (priorityInfo.timeoutTime_ms != -1)
|
|
{
|
|
item["duration_ms"] = int(priorityInfo.timeoutTime_ms - now);
|
|
}
|
|
|
|
item["owner"] = QString("unknown");
|
|
item["active"] = true;
|
|
item["visible"] = (priority == currentPriority);
|
|
foreach(auto const &entry, priorityRegister)
|
|
{
|
|
if (entry.second == priority)
|
|
{
|
|
item["owner"] = QString::fromStdString(entry.first);
|
|
priorityRegister.erase(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// priorities[priorities.size()] = item;
|
|
priorities.append(item);
|
|
}
|
|
|
|
foreach(auto const &entry, priorityRegister)
|
|
{
|
|
QJsonObject item;
|
|
item["priority"] = entry.second;
|
|
item["active"] = false;
|
|
item["visible"] = false;
|
|
item["owner"] = QString::fromStdString(entry.first);
|
|
priorities.append(item);
|
|
}
|
|
|
|
info["priorities"] = priorities;
|
|
|
|
// collect transform information
|
|
QJsonArray transformArray;
|
|
for (const std::string& transformId : _hyperion->getTransformIds())
|
|
{
|
|
const ColorTransform * colorTransform = _hyperion->getTransform(transformId);
|
|
if (colorTransform == nullptr)
|
|
{
|
|
Error(_log, "Incorrect color transform id: %s", transformId.c_str());
|
|
continue;
|
|
}
|
|
|
|
QJsonObject transform;
|
|
transform["id"] = QString::fromStdString(transformId);
|
|
|
|
transform["saturationGain"] = colorTransform->_hsvTransform.getSaturationGain();
|
|
transform["valueGain"] = colorTransform->_hsvTransform.getValueGain();
|
|
transform["saturationLGain"] = colorTransform->_hslTransform.getSaturationGain();
|
|
transform["luminanceGain"] = colorTransform->_hslTransform.getLuminanceGain();
|
|
transform["luminanceMinimum"] = colorTransform->_hslTransform.getLuminanceMinimum();
|
|
|
|
|
|
QJsonArray threshold;
|
|
threshold.append(colorTransform->_rgbRedTransform.getThreshold());
|
|
threshold.append(colorTransform->_rgbGreenTransform.getThreshold());
|
|
threshold.append(colorTransform->_rgbBlueTransform.getThreshold());
|
|
transform.insert("threshold", threshold);
|
|
|
|
QJsonArray gamma;
|
|
gamma.append(colorTransform->_rgbRedTransform.getGamma());
|
|
gamma.append(colorTransform->_rgbGreenTransform.getGamma());
|
|
gamma.append(colorTransform->_rgbBlueTransform.getGamma());
|
|
transform.insert("gamma", gamma);
|
|
|
|
QJsonArray blacklevel;
|
|
blacklevel.append(colorTransform->_rgbRedTransform.getBlacklevel());
|
|
blacklevel.append(colorTransform->_rgbGreenTransform.getBlacklevel());
|
|
blacklevel.append(colorTransform->_rgbBlueTransform.getBlacklevel());
|
|
transform.insert("blacklevel", blacklevel);
|
|
|
|
QJsonArray whitelevel;
|
|
whitelevel.append(colorTransform->_rgbRedTransform.getWhitelevel());
|
|
whitelevel.append(colorTransform->_rgbGreenTransform.getWhitelevel());
|
|
whitelevel.append(colorTransform->_rgbBlueTransform.getWhitelevel());
|
|
transform.insert("whitelevel", whitelevel);
|
|
|
|
transformArray.append(transform);
|
|
}
|
|
|
|
info["transform"] = transformArray;
|
|
|
|
// collect adjustment information
|
|
QJsonArray adjustmentArray;
|
|
for (const std::string& adjustmentId : _hyperion->getAdjustmentIds())
|
|
{
|
|
const ColorAdjustment * colorAdjustment = _hyperion->getAdjustment(adjustmentId);
|
|
if (colorAdjustment == nullptr)
|
|
{
|
|
Error(_log, "Incorrect color adjustment id: %s", adjustmentId.c_str());
|
|
continue;
|
|
}
|
|
|
|
QJsonObject adjustment;
|
|
adjustment["id"] = QString::fromStdString(adjustmentId);
|
|
|
|
QJsonArray redAdjust;
|
|
redAdjust.append(colorAdjustment->_rgbRedAdjustment.getAdjustmentR());
|
|
redAdjust.append(colorAdjustment->_rgbRedAdjustment.getAdjustmentG());
|
|
redAdjust.append(colorAdjustment->_rgbRedAdjustment.getAdjustmentB());
|
|
adjustment.insert("redAdjust", redAdjust);
|
|
|
|
QJsonArray greenAdjust;
|
|
greenAdjust.append(colorAdjustment->_rgbGreenAdjustment.getAdjustmentR());
|
|
greenAdjust.append(colorAdjustment->_rgbGreenAdjustment.getAdjustmentG());
|
|
greenAdjust.append(colorAdjustment->_rgbGreenAdjustment.getAdjustmentB());
|
|
adjustment.insert("greenAdjust", greenAdjust);
|
|
|
|
QJsonArray blueAdjust;
|
|
blueAdjust.append(colorAdjustment->_rgbBlueAdjustment.getAdjustmentR());
|
|
blueAdjust.append(colorAdjustment->_rgbBlueAdjustment.getAdjustmentG());
|
|
blueAdjust.append(colorAdjustment->_rgbBlueAdjustment.getAdjustmentB());
|
|
adjustment.insert("blueAdjust", blueAdjust);
|
|
|
|
adjustmentArray.append(adjustment);
|
|
}
|
|
|
|
info["adjustment"] = adjustmentArray;
|
|
|
|
// collect effect info
|
|
QJsonArray effects;
|
|
const std::list<EffectDefinition> & effectsDefinitions = _hyperion->getEffects();
|
|
for (const EffectDefinition & effectDefinition : effectsDefinitions)
|
|
{
|
|
QJsonObject effect;
|
|
effect["name"] = effectDefinition.name;
|
|
effect["file"] = effectDefinition.file;
|
|
effect["script"] = effectDefinition.script;
|
|
effect["args"] = effectDefinition.args;
|
|
effects.append(effect);
|
|
}
|
|
|
|
info["effects"] = effects;
|
|
|
|
// collect active effect info
|
|
QJsonArray activeEffects;
|
|
const std::list<ActiveEffectDefinition> & activeEffectsDefinitions = _hyperion->getActiveEffects();
|
|
for (const ActiveEffectDefinition & activeEffectDefinition : activeEffectsDefinitions)
|
|
{
|
|
if (activeEffectDefinition.priority != PriorityMuxer::LOWEST_PRIORITY -1)
|
|
{
|
|
QJsonObject activeEffect;
|
|
activeEffect["script"] = activeEffectDefinition.script;
|
|
activeEffect["name"] = activeEffectDefinition.name;
|
|
activeEffect["priority"] = activeEffectDefinition.priority;
|
|
activeEffect["timeout"] = activeEffectDefinition.timeout;
|
|
activeEffect["args"] = activeEffectDefinition.args;
|
|
activeEffects.append(activeEffect);
|
|
}
|
|
}
|
|
|
|
info["activeEffects"] = activeEffects;
|
|
|
|
// collect active static led color
|
|
QJsonArray activeLedColors;
|
|
const Hyperion::InputInfo & priorityInfo = _hyperion->getPriorityInfo(_hyperion->getCurrentPriority());
|
|
if (priorityInfo.priority != std::numeric_limits<int>::max())
|
|
{
|
|
QJsonObject LEDcolor;
|
|
// check if all LEDs has the same Color
|
|
if (std::all_of(priorityInfo.ledColors.begin(), priorityInfo.ledColors.end(), [&](ColorRgb color)
|
|
{
|
|
return ((color.red == priorityInfo.ledColors.begin()->red) &&
|
|
(color.green == priorityInfo.ledColors.begin()->green) &&
|
|
(color.blue == priorityInfo.ledColors.begin()->blue));
|
|
} ))
|
|
{
|
|
// check if LED Color not Black (0,0,0)
|
|
if ((priorityInfo.ledColors.begin()->red +
|
|
priorityInfo.ledColors.begin()->green +
|
|
priorityInfo.ledColors.begin()->blue != 0))
|
|
{
|
|
// add RGB Value to Array
|
|
QJsonArray RGBValue;
|
|
RGBValue.append(priorityInfo.ledColors.begin()->red);
|
|
RGBValue.append(priorityInfo.ledColors.begin()->green);
|
|
RGBValue.append(priorityInfo.ledColors.begin()->blue);
|
|
LEDcolor.insert("RGB Value", RGBValue);
|
|
|
|
uint16_t Hue;
|
|
float Saturation, Luminace;
|
|
|
|
// add HSL Value to Array
|
|
QJsonArray HSLValue;
|
|
HslTransform::rgb2hsl(priorityInfo.ledColors.begin()->red,
|
|
priorityInfo.ledColors.begin()->green,
|
|
priorityInfo.ledColors.begin()->blue,
|
|
Hue, Saturation, Luminace);
|
|
|
|
HSLValue.append(Hue);
|
|
HSLValue.append(Saturation);
|
|
HSLValue.append(Luminace);
|
|
LEDcolor.insert("HSL Value", HSLValue);
|
|
|
|
// add HEX Value to Array ["HEX Value"]
|
|
QJsonArray HEXValue;
|
|
std::stringstream hex;
|
|
hex << "0x"
|
|
<< std::uppercase << std::setw(2) << std::setfill('0')
|
|
<< std::hex << unsigned(priorityInfo.ledColors.begin()->red)
|
|
<< std::uppercase << std::setw(2) << std::setfill('0')
|
|
<< std::hex << unsigned(priorityInfo.ledColors.begin()->green)
|
|
<< std::uppercase << std::setw(2) << std::setfill('0')
|
|
<< std::hex << unsigned(priorityInfo.ledColors.begin()->blue);
|
|
|
|
HEXValue.append(QString::fromStdString(hex.str()));
|
|
LEDcolor.insert("HEX Value", HEXValue);
|
|
|
|
activeLedColors.append(LEDcolor);
|
|
}
|
|
}
|
|
}
|
|
|
|
info["activeLedColor"] = activeLedColors;
|
|
|
|
// get available led devices
|
|
QJsonObject ledDevices;
|
|
ledDevices["active"] = QString::fromStdString(LedDevice::activeDevice());
|
|
QJsonArray available;
|
|
for (auto dev: LedDevice::getDeviceMap())
|
|
{
|
|
available.append(QString::fromStdString(dev.first));
|
|
}
|
|
|
|
ledDevices["available"] = available;
|
|
info["ledDevices"] = ledDevices;
|
|
|
|
// get available components
|
|
QJsonArray component;
|
|
std::map<hyperion::Components, bool> components = _hyperion->getComponentRegister().getRegister();
|
|
for(auto comp : components)
|
|
{
|
|
QJsonObject item;
|
|
item["id"] = comp.first;
|
|
item["name"] = QString::fromStdString(hyperion::componentToIdString(comp.first));
|
|
item["title"] = QString::fromStdString(hyperion::componentToString(comp.first));
|
|
item["enabled"] = comp.second;
|
|
|
|
component.append(item);
|
|
}
|
|
|
|
info["components"] = component;
|
|
|
|
// Add Hyperion Version, build time
|
|
QJsonArray hyperion;
|
|
QJsonObject ver;
|
|
ver["jsonrpc_version"] = QString(HYPERION_JSON_VERSION);
|
|
ver["version"] = QString(HYPERION_VERSION);
|
|
ver["build"] = QString(HYPERION_BUILD_ID);
|
|
ver["time"] = QString(__DATE__ " " __TIME__);
|
|
ver["config_modified"] = _hyperion->configModified();
|
|
|
|
hyperion.append(ver);
|
|
info["hyperion"] = hyperion;
|
|
|
|
// send the result
|
|
result["info"] = info;
|
|
sendMessage(result);
|
|
}
|
|
|
|
void JsonClientConnection::handleClearCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
forwardJsonMessage(message);
|
|
|
|
// extract parameters
|
|
int priority = message["priority"].toInt();
|
|
|
|
// clear priority
|
|
_hyperion->clear(priority);
|
|
|
|
// send reply
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleClearallCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
forwardJsonMessage(message);
|
|
|
|
// clear priority
|
|
_hyperion->clearall();
|
|
|
|
// send reply
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleTransformCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
|
|
const QJsonObject & transform = message["transform"].toObject();
|
|
|
|
const QString transformId = transform["id"].toString(QString::fromStdString(_hyperion->getTransformIds().front()));
|
|
ColorTransform * colorTransform = _hyperion->getTransform(transformId.toStdString());
|
|
if (colorTransform == nullptr)
|
|
{
|
|
Warning(_log, "Incorrect transform identifier: %s", transformId.toStdString().c_str());
|
|
return;
|
|
}
|
|
|
|
if (transform.contains("saturationGain"))
|
|
{
|
|
colorTransform->_hsvTransform.setSaturationGain(transform["saturationGain"].toDouble());
|
|
}
|
|
|
|
if (transform.contains("valueGain"))
|
|
{
|
|
colorTransform->_hsvTransform.setValueGain(transform["valueGain"].toDouble());
|
|
}
|
|
|
|
if (transform.contains("saturationLGain"))
|
|
{
|
|
colorTransform->_hslTransform.setSaturationGain(transform["saturationLGain"].toDouble());
|
|
}
|
|
|
|
if (transform.contains("luminanceGain"))
|
|
{
|
|
colorTransform->_hslTransform.setLuminanceGain(transform["luminanceGain"].toDouble());
|
|
}
|
|
|
|
if (transform.contains("luminanceMinimum"))
|
|
{
|
|
colorTransform->_hslTransform.setLuminanceMinimum(transform["luminanceMinimum"].toDouble());
|
|
}
|
|
|
|
if (transform.contains("threshold"))
|
|
{
|
|
const QJsonArray & values = transform["threshold"].toArray();
|
|
colorTransform->_rgbRedTransform .setThreshold(values[0u].toDouble());
|
|
colorTransform->_rgbGreenTransform.setThreshold(values[1u].toDouble());
|
|
colorTransform->_rgbBlueTransform .setThreshold(values[2u].toDouble());
|
|
}
|
|
|
|
if (transform.contains("gamma"))
|
|
{
|
|
const QJsonArray & values = transform["gamma"].toArray();
|
|
colorTransform->_rgbRedTransform .setGamma(values[0u].toDouble());
|
|
colorTransform->_rgbGreenTransform.setGamma(values[1u].toDouble());
|
|
colorTransform->_rgbBlueTransform .setGamma(values[2u].toDouble());
|
|
}
|
|
|
|
if (transform.contains("blacklevel"))
|
|
{
|
|
const QJsonArray & values = transform["blacklevel"].toArray();
|
|
colorTransform->_rgbRedTransform .setBlacklevel(values[0u].toDouble());
|
|
colorTransform->_rgbGreenTransform.setBlacklevel(values[1u].toDouble());
|
|
colorTransform->_rgbBlueTransform .setBlacklevel(values[2u].toDouble());
|
|
}
|
|
|
|
if (transform.contains("whitelevel"))
|
|
{
|
|
const QJsonArray & values = transform["whitelevel"].toArray();
|
|
colorTransform->_rgbRedTransform .setWhitelevel(values[0u].toDouble());
|
|
colorTransform->_rgbGreenTransform.setWhitelevel(values[1u].toDouble());
|
|
colorTransform->_rgbBlueTransform .setWhitelevel(values[2u].toDouble());
|
|
}
|
|
|
|
// commit the changes
|
|
_hyperion->transformsUpdated();
|
|
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
|
|
|
|
void JsonClientConnection::handleAdjustmentCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
const QJsonObject & adjustment = message["adjustment"].toObject();
|
|
|
|
const QString adjustmentId = adjustment["id"].toString(QString::fromStdString(_hyperion->getAdjustmentIds().front()));
|
|
ColorAdjustment * colorAdjustment = _hyperion->getAdjustment(adjustmentId.toStdString());
|
|
if (colorAdjustment == nullptr)
|
|
{
|
|
Warning(_log, "Incorrect adjustment identifier: %s", adjustmentId.toStdString().c_str());
|
|
return;
|
|
}
|
|
|
|
if (adjustment.contains("redAdjust"))
|
|
{
|
|
const QJsonArray & values = adjustment["redAdjust"].toArray();
|
|
colorAdjustment->_rgbRedAdjustment.setAdjustmentR(values[0u].toInt());
|
|
colorAdjustment->_rgbRedAdjustment.setAdjustmentG(values[1u].toInt());
|
|
colorAdjustment->_rgbRedAdjustment.setAdjustmentB(values[2u].toInt());
|
|
}
|
|
|
|
if (adjustment.contains("greenAdjust"))
|
|
{
|
|
const QJsonArray & values = adjustment["greenAdjust"].toArray();
|
|
colorAdjustment->_rgbGreenAdjustment.setAdjustmentR(values[0u].toInt());
|
|
colorAdjustment->_rgbGreenAdjustment.setAdjustmentG(values[1u].toInt());
|
|
colorAdjustment->_rgbGreenAdjustment.setAdjustmentB(values[2u].toInt());
|
|
}
|
|
|
|
if (adjustment.contains("blueAdjust"))
|
|
{
|
|
const QJsonArray & values = adjustment["blueAdjust"].toArray();
|
|
colorAdjustment->_rgbBlueAdjustment.setAdjustmentR(values[0u].toInt());
|
|
colorAdjustment->_rgbBlueAdjustment.setAdjustmentG(values[1u].toInt());
|
|
colorAdjustment->_rgbBlueAdjustment.setAdjustmentB(values[2u].toInt());
|
|
}
|
|
// commit the changes
|
|
_hyperion->adjustmentsUpdated();
|
|
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleSourceSelectCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
bool success = false;
|
|
if (message["auto"].toBool(false))
|
|
{
|
|
_hyperion->setSourceAutoSelectEnabled(true);
|
|
success = true;
|
|
}
|
|
else if (message.contains("priority"))
|
|
{
|
|
success = _hyperion->setCurrentSourcePriority(message["priority"].toInt());
|
|
}
|
|
|
|
if (success)
|
|
{
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
else
|
|
{
|
|
sendErrorReply("setting current priority failed", command, tan);
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::handleConfigCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
QString subcommand = message["subcommand"].toString("");
|
|
QString full_command = command + "-" + subcommand;
|
|
if (subcommand == "getschema")
|
|
{
|
|
handleSchemaGetCommand(message, full_command, tan);
|
|
}
|
|
else if (subcommand == "getconfig")
|
|
{
|
|
handleConfigGetCommand(message, full_command, tan);
|
|
}
|
|
else if (subcommand == "setconfig")
|
|
{
|
|
handleConfigSetCommand(message, full_command, tan);
|
|
}
|
|
else if (subcommand == "reload")
|
|
{
|
|
_hyperion->freeObjects();
|
|
Process::restartHyperion();
|
|
sendErrorReply("failed to restart hyperion", full_command, tan);
|
|
}
|
|
else
|
|
{
|
|
sendErrorReply("unknown or missing subcommand", full_command, tan);
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::handleConfigGetCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
// create result
|
|
QJsonObject result;
|
|
result["success"] = true;
|
|
result["command"] = command;
|
|
result["tan"] = tan;
|
|
|
|
try
|
|
{
|
|
result["result"] = QJsonFactory::readJson(QString::fromStdString(_hyperion->getConfigFileName()));
|
|
}
|
|
catch(...)
|
|
{
|
|
result["result"] = _hyperion->getQJsonConfig();
|
|
}
|
|
|
|
// send the result
|
|
sendMessage(result);
|
|
}
|
|
|
|
void JsonClientConnection::handleSchemaGetCommand(const QJsonObject& message, const QString& command, const int tan)
|
|
{
|
|
// create result
|
|
QJsonObject result, schemaJson, alldevices, properties;
|
|
result["success"] = true;
|
|
result["command"] = command;
|
|
result["tan"] = tan;
|
|
|
|
// make sure the resources are loaded (they may be left out after static linking)
|
|
Q_INIT_RESOURCE(resource);
|
|
QJsonParseError error;
|
|
|
|
// read the hyperion json schema from the resource
|
|
QFile schemaData(":/hyperion-schema");
|
|
|
|
if (!schemaData.open(QIODevice::ReadOnly))
|
|
{
|
|
std::stringstream error;
|
|
error << "Schema not found: " << schemaData.errorString().toStdString();
|
|
throw std::runtime_error(error.str());
|
|
}
|
|
|
|
QByteArray schema = schemaData.readAll();
|
|
QJsonDocument doc = QJsonDocument::fromJson(schema, &error);
|
|
schemaData.close();
|
|
|
|
if (error.error != QJsonParseError::NoError)
|
|
{
|
|
// report to the user the failure and their locations in the document.
|
|
int errorLine(0), errorColumn(0);
|
|
|
|
for( int i=0, count=qMin( error.offset,schema.size()); i<count; ++i )
|
|
{
|
|
++errorColumn;
|
|
if(schema.at(i) == '\n' )
|
|
{
|
|
errorColumn = 0;
|
|
++errorLine;
|
|
}
|
|
}
|
|
|
|
std::stringstream sstream;
|
|
sstream << "ERROR: Json schema wrong: " << error.errorString().toStdString() << " at Line: " << errorLine << ", Column: " << errorColumn;
|
|
|
|
throw std::runtime_error(sstream.str());
|
|
}
|
|
|
|
schemaJson = doc.object();
|
|
|
|
// collect all LED Devices
|
|
properties = schemaJson["properties"].toObject();
|
|
alldevices = LedDevice::getLedDeviceSchemas();
|
|
properties.insert("alldevices", alldevices);
|
|
|
|
// collect all available effect schemas
|
|
QJsonObject pyEffectSchemas, pyEffectSchema;
|
|
QJsonArray in, ex;
|
|
const std::list<EffectSchema> & effectsSchemas = _hyperion->getEffectSchemas();
|
|
for (const EffectSchema & effectSchema : effectsSchemas)
|
|
{
|
|
if (effectSchema.pyFile.mid(0, 1) == ":")
|
|
{
|
|
QJsonObject internal;
|
|
internal.insert("script", effectSchema.pyFile);
|
|
internal.insert("schemaLocation", effectSchema.schemaFile);
|
|
internal.insert("schemaContent", effectSchema.pySchema);
|
|
in.append(internal);
|
|
}
|
|
else
|
|
{
|
|
QJsonObject external;
|
|
external.insert("script", effectSchema.pyFile);
|
|
external.insert("schemaLocation", effectSchema.schemaFile);
|
|
external.insert("schemaContent", effectSchema.pySchema);
|
|
ex.append(external);
|
|
}
|
|
}
|
|
|
|
if (!in.empty())
|
|
pyEffectSchema.insert("internal", in);
|
|
if (!ex.empty())
|
|
pyEffectSchema.insert("external", ex);
|
|
|
|
pyEffectSchemas = pyEffectSchema;
|
|
properties.insert("effectSchemas", pyEffectSchemas);
|
|
|
|
schemaJson.insert("properties", properties);
|
|
|
|
result["result"] = schemaJson;
|
|
|
|
// send the result
|
|
sendMessage(result);
|
|
}
|
|
|
|
void JsonClientConnection::handleConfigSetCommand(const QJsonObject& message, const QString &command, const int tan)
|
|
{
|
|
if(message.size() > 0)
|
|
{
|
|
if (message.contains("config"))
|
|
{
|
|
QString errors;
|
|
if (!checkJson(message["config"].toObject(), ":/hyperion-schema", errors, true))
|
|
{
|
|
sendErrorReply("Error while validating json: " + errors, command, tan);
|
|
return;
|
|
}
|
|
|
|
QJsonObject hyperionConfig = message["config"].toObject();
|
|
QJsonFactory::writeJson(QString::fromStdString(_hyperion->getConfigFileName()), hyperionConfig);
|
|
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
} else
|
|
sendErrorReply("Error while parsing json: Message size " + QString(message.size()), command, tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleComponentStateCommand(const QJsonObject& message, const QString &command, const int tan)
|
|
{
|
|
const QJsonObject & componentState = message["componentstate"].toObject();
|
|
Components component = stringToComponent(componentState["component"].toString("invalid"));
|
|
|
|
if (component != COMP_INVALID)
|
|
{
|
|
_hyperion->setComponentState(component, componentState["state"].toBool(true));
|
|
sendSuccessReply(command, tan);
|
|
}
|
|
else
|
|
{
|
|
sendErrorReply("invalid component name", command, tan);
|
|
}
|
|
}
|
|
|
|
void JsonClientConnection::handleLedColorsCommand(const QJsonObject& message, const QString &command, const int tan)
|
|
{
|
|
// create result
|
|
QString subcommand = message["subcommand"].toString("");
|
|
_streaming_leds_reply["success"] = true;
|
|
_streaming_leds_reply["command"] = command;
|
|
_streaming_leds_reply["tan"] = tan;
|
|
|
|
if (subcommand == "ledstream-start")
|
|
{
|
|
_streaming_leds_reply["command"] = command+"-ledstream-update";
|
|
_timer_ledcolors.start(125);
|
|
}
|
|
else if (subcommand == "ledstream-stop")
|
|
{
|
|
_timer_ledcolors.stop();
|
|
}
|
|
else
|
|
{
|
|
sendErrorReply("unknown subcommand",command,tan);
|
|
return;
|
|
}
|
|
|
|
sendSuccessReply(command+"-"+subcommand,tan);
|
|
}
|
|
|
|
void JsonClientConnection::handleLoggingCommand(const QJsonObject& message, const QString &command, const int tan)
|
|
{
|
|
// create result
|
|
QString subcommand = message["subcommand"].toString("");
|
|
_streaming_logging_reply["success"] = true;
|
|
_streaming_logging_reply["command"] = command;
|
|
_streaming_logging_reply["tan"] = tan;
|
|
|
|
if (subcommand == "start")
|
|
{
|
|
if (!_streaming_logging_activated)
|
|
{
|
|
_streaming_logging_reply["command"] = command+"-update";
|
|
connect(LoggerManager::getInstance(),SIGNAL(newLogMessage(Logger::T_LOG_MESSAGE)), this, SLOT(incommingLogMessage(Logger::T_LOG_MESSAGE)));
|
|
Debug(_log, "log streaming activated"); // needed to trigger log sending
|
|
}
|
|
}
|
|
else if (subcommand == "stop")
|
|
{
|
|
if (_streaming_logging_activated)
|
|
{
|
|
disconnect(LoggerManager::getInstance(), SIGNAL(newLogMessage(Logger::T_LOG_MESSAGE)), this, 0);
|
|
_streaming_logging_activated = false;
|
|
Debug(_log, "log streaming deactivated");
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendErrorReply("unknown subcommand",command,tan);
|
|
return;
|
|
}
|
|
|
|
sendSuccessReply(command+"-"+subcommand,tan);
|
|
}
|
|
|
|
void JsonClientConnection::incommingLogMessage(Logger::T_LOG_MESSAGE msg)
|
|
{
|
|
QJsonObject result;
|
|
QJsonArray messages;
|
|
|
|
if (!_streaming_logging_activated)
|
|
{
|
|
_streaming_logging_activated = true;
|
|
QVector<Logger::T_LOG_MESSAGE>* logBuffer = LoggerManager::getInstance()->getLogMessageBuffer();
|
|
for(int i=0; i<logBuffer->length(); i++)
|
|
{
|
|
//std::cout << "------- " << logBuffer->at(i).message.toStdString() << std::endl;
|
|
messages.append(logBuffer->at(i).message);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//std::cout << "------- " << msg.message.toStdString() << std::endl;
|
|
messages.append(msg.message);
|
|
}
|
|
|
|
result["messages"] = messages;
|
|
_streaming_logging_reply["result"] = result;
|
|
|
|
// send the result
|
|
sendMessage(_streaming_logging_reply);
|
|
}
|
|
|
|
|
|
void JsonClientConnection::handleNotImplemented()
|
|
{
|
|
sendErrorReply("Command not implemented");
|
|
}
|
|
|
|
void JsonClientConnection::sendMessage(const QJsonObject &message)
|
|
{
|
|
QJsonDocument writer(message);
|
|
QByteArray serializedReply = writer.toJson(QJsonDocument::Compact) + "\n";
|
|
|
|
if (!_webSocketHandshakeDone)
|
|
{
|
|
// raw tcp socket mode
|
|
_socket->write(serializedReply.data(), serializedReply.length());
|
|
} else
|
|
{
|
|
// websocket mode
|
|
quint32 size = serializedReply.length();
|
|
|
|
// prepare data frame
|
|
QByteArray response;
|
|
response.append(0x81);
|
|
if (size > 125)
|
|
{
|
|
response.append(0x7E);
|
|
response.append((size >> 8) & 0xFF);
|
|
response.append(size & 0xFF);
|
|
} else {
|
|
response.append(size);
|
|
}
|
|
|
|
response.append(serializedReply, serializedReply.length());
|
|
|
|
_socket->write(response.data(), response.length());
|
|
}
|
|
}
|
|
|
|
|
|
void JsonClientConnection::sendMessage(const QJsonObject & message, QTcpSocket * socket)
|
|
{
|
|
// serialize message
|
|
QJsonDocument writer(message);
|
|
QByteArray serializedMessage = writer.toJson(QJsonDocument::Compact) + "\n";
|
|
|
|
// write message
|
|
socket->write(serializedMessage);
|
|
if (!socket->waitForBytesWritten())
|
|
{
|
|
Debug(_log, "Error while writing data to host");
|
|
return;
|
|
}
|
|
|
|
// read reply data
|
|
QByteArray serializedReply;
|
|
while (!serializedReply.contains('\n'))
|
|
{
|
|
// receive reply
|
|
if (!socket->waitForReadyRead())
|
|
{
|
|
Debug(_log, "Error while writing data from host");
|
|
return;
|
|
}
|
|
|
|
serializedReply += socket->readAll();
|
|
}
|
|
|
|
// parse reply data
|
|
QJsonParseError error;
|
|
QJsonDocument reply = QJsonDocument::fromJson(serializedReply ,&error);
|
|
|
|
if (error.error != QJsonParseError::NoError)
|
|
{
|
|
Error(_log, "Error while parsing reply: invalid json");
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
void JsonClientConnection::sendSuccessReply(const QString &command, const int tan)
|
|
{
|
|
// create reply
|
|
QJsonObject reply;
|
|
reply["success"] = true;
|
|
reply["command"] = command;
|
|
reply["tan"] = tan;
|
|
|
|
// send reply
|
|
sendMessage(reply);
|
|
}
|
|
|
|
void JsonClientConnection::sendErrorReply(const QString &error, const QString &command, const int tan)
|
|
{
|
|
// create reply
|
|
QJsonObject reply;
|
|
reply["success"] = false;
|
|
reply["error"] = error;
|
|
reply["command"] = command;
|
|
reply["tan"] = tan;
|
|
|
|
// send reply
|
|
sendMessage(reply);
|
|
}
|
|
|
|
bool JsonClientConnection::checkJson(const QJsonObject& message, const QString& schemaResource, QString& errorMessage, bool ignoreRequired)
|
|
{
|
|
// make sure the resources are loaded (they may be left out after static linking)
|
|
Q_INIT_RESOURCE(JsonSchemas);
|
|
QJsonParseError error;
|
|
|
|
// read the json schema from the resource
|
|
QFile schemaData(schemaResource);
|
|
if (!schemaData.open(QIODevice::ReadOnly))
|
|
{
|
|
errorMessage = "Schema error: " + schemaData.errorString();
|
|
return false;
|
|
}
|
|
|
|
// create schema checker
|
|
QByteArray schema = schemaData.readAll();
|
|
QJsonDocument schemaJson = QJsonDocument::fromJson(schema, &error);
|
|
schemaData.close();
|
|
|
|
if (error.error != QJsonParseError::NoError)
|
|
{
|
|
// report to the user the failure and their locations in the document.
|
|
int errorLine(0), errorColumn(0);
|
|
|
|
for( int i=0, count=qMin( error.offset,schema.size()); i<count; ++i )
|
|
{
|
|
++errorColumn;
|
|
if(schema.at(i) == '\n' )
|
|
{
|
|
errorColumn = 0;
|
|
++errorLine;
|
|
}
|
|
}
|
|
|
|
std::stringstream sstream;
|
|
sstream << "Schema error: " << error.errorString().toStdString() << " at Line: " << errorLine << ", Column: " << errorColumn;
|
|
errorMessage = QString::fromStdString(sstream.str());
|
|
return false;
|
|
}
|
|
|
|
QJsonSchemaChecker schemaChecker;
|
|
schemaChecker.setSchema(schemaJson.object());
|
|
|
|
// check the message
|
|
if (!schemaChecker.validate(message, ignoreRequired))
|
|
{
|
|
const std::list<std::string> & errors = schemaChecker.getMessages();
|
|
std::stringstream ss;
|
|
ss << "{";
|
|
foreach (const std::string & error, errors)
|
|
{
|
|
ss << error << " ";
|
|
}
|
|
ss << "}";
|
|
errorMessage = QString::fromStdString(ss.str());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void JsonClientConnection::streamLedcolorsUpdate()
|
|
{
|
|
QJsonObject result;
|
|
QJsonArray leds;
|
|
|
|
const PriorityMuxer::InputInfo & priorityInfo = _hyperion->getPriorityInfo(_hyperion->getCurrentPriority());
|
|
for(auto color = priorityInfo.ledColors.begin(); color != priorityInfo.ledColors.end(); ++color)
|
|
{
|
|
QJsonObject item;
|
|
item["index"] = int(color - priorityInfo.ledColors.begin());
|
|
item["red"] = color->red;
|
|
item["green"] = color->green;
|
|
item["blue"] = color->blue;
|
|
leds.append(item);
|
|
}
|
|
|
|
result["leds"] = leds;
|
|
_streaming_leds_reply["result"] = result;
|
|
|
|
// send the result
|
|
sendMessage(_streaming_leds_reply);
|
|
|
|
}
|