Backwards compatibility ensured

assets/webconfig/index.html

@@ -179,7 +179,10 @@
 							<ul class="nav nav-second-level">
 								<li> <a class="inactive mnava" href="#conf_webconfig" id="load_webconfig"><i class="fa fa-wrench fa-fw"></i><span  data-i18n="main_menu_webconfig_token">Webconfiguration</span></a> </li>
 								<li> <a class="inactive mnava" href="#conf_logging"><i class="fa fa-reorder fa-fw"></i><span  data-i18n="main_menu_logging_token">Log</span></a> </li>
-								<li> <a class="inactive mnava" href="#update"><i class="fa fa-download fa-fw"></i><span  data-i18n="main_menu_update_token">Update</span></a> </li>
+
+<!-- 							Update is disabled
+							 	<li> <a class="inactive mnava" href="#update"><i class="fa fa-download fa-fw"></i><span  data-i18n="main_menu_update_token">Update</span></a> </li>
+-->
 								<li> <a class="inactive mnava" href="#about"><i class="fa fa-info-circle fa-fw"></i><span  data-i18n="main_menu_about_token">Update</span></a> </li>
 							</ul>
 						</li>

assets/webconfig/server_scripts/demo.py

@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-
-print ("hello world");
-
-

include/api/JsonAPI.h

@@ -214,6 +214,13 @@ private:
 	///
 	void handleVideoModeCommand(const QJsonObject & message, const QString &command, const int tan);
 
+	///
+	/// Handle an incoming JSON Clearall message
+	///
+	/// @param message the incoming message
+	///
+	void handleClearallCommand(const QJsonObject & message, const QString &command, const int tan);
+
 	///
 	/// Handle an incoming JSON message of unknown type
 	///

include/hyperion/Hyperion.h

@@ -208,7 +208,7 @@ public:
 	/// @param[in] priority    The priority of the channel
 	/// @param[in] component   The component of the channel
 	/// @param[in] origin      Who set the channel (CustomString@IP)
-	/// @param[in] owner       Speicifc owner string, might be empty
+	/// @param[in] owner       Specific owner string, might be empty
 	/// @param[in] smooth_cfg  The smooth id to use
 	///
 	void registerInput(const int priority, const hyperion::Components& component, const QString& origin = "System", const QString& owner = "", unsigned smooth_cfg = 0);

include/webserver/WebSocketClient.h

@@ -1,18 +1,16 @@
 #pragma once
 
 #include <utils/Logger.h>
-#include "WebSocketUtils.h"
+#include "webserver/WebSocketUtils.h"
+#include <QJsonObject>
 
 class QTcpSocket;
-
-class QtHttpRequest;
-class Hyperion;
 class JsonAPI;
 
 class WebSocketClient : public QObject {
 	Q_OBJECT
 public:
-	WebSocketClient(QtHttpRequest* request, QTcpSocket* sock, QObject* parent);
+	WebSocketClient(QByteArray socketKey, QTcpSocket* sock, QObject* parent);
 
 	struct WebSocketHeader
 	{
@@ -25,13 +23,13 @@ public:
 
 private:
 	QTcpSocket* _socket;
+	QByteArray _secWebSocketKey;
 	Logger* _log;
-	Hyperion* _hyperion;
 	JsonAPI* _jsonAPI;
 
 	void getWsFrameHeader(WebSocketHeader* header);
 	void sendClose(int status, QString reason = "");
-	void handleBinaryMessage(QByteArray &data);
+//	void handleBinaryMessage(QByteArray &data);
 	qint64 sendMessage_Raw(const char* data, quint64 size);
 	qint64 sendMessage_Raw(QByteArray &data);
 	QByteArray makeFrameHeader(quint8 opCode, quint64 payloadLength, bool lastFrame);

libsrc/api/JSONRPC_schema/schema-clearall.json

@@ -0,0 +1,15 @@
+{
+	"type":"object",
+	"required":true,
+	"properties":{
+		"command": {
+			"type" : "string",
+			"required" : true,
+			"enum" : ["clearall"]
+		},
+		"tan" : {
+			"type" : "integer"
+		}
+	},
+	"additionalProperties": false
+}

libsrc/api/JSONRPC_schema/schema-color.json

@@ -24,7 +24,7 @@
 			"type": "string",
 			"minLength" : 4,
 			"maxLength" : 20,
-			"required": true
+			"required": false
 		},
 		"color": {
 			"type": "array",

libsrc/api/JSONRPC_schema/schema-effect.json

@@ -24,7 +24,7 @@
 			"type": "string",
 			"minLength" : 4,
 			"maxLength" : 20,
-			"required": true
+			"required": false
 		},
 		"effect": {
 			"type": "object",

libsrc/api/JSONRPC_schema/schema-hyperion-classic.json

@@ -0,0 +1,12 @@
+{
+	"type":"object",
+	"required":true,
+	"properties":{
+		"command": {
+			"title" : "This schema is used to ensure backward compatibility with hyperion classic",
+			"type" : "string",
+			"required" : false
+		}
+	},
+	"additionalProperties": true
+}

libsrc/api/JSONRPC_schema/schema.json

@@ -5,7 +5,7 @@
 		"command": {
 			"type" : "string",
 			"required" : true,
-			"enum" : ["color", "image", "effect", "create-effect", "delete-effect", "serverinfo", "clear", "clearall", "adjustment", "sourceselect", "config", "componentstate", "ledcolors", "logging", "processing", "sysinfo", "videomode"]
+			"enum" : ["color", "image", "effect", "create-effect", "delete-effect", "serverinfo", "clear", "clearall", "adjustment", "sourceselect", "config", "componentstate", "ledcolors", "logging", "processing", "sysinfo", "videomode", "transform", "correction" , "temperature"]
 		}
 	}
 }

libsrc/api/JSONRPC_schemas.qrc

@@ -6,6 +6,7 @@
         <file alias="schema-serverinfo">JSONRPC_schema/schema-serverinfo.json</file>
         <file alias="schema-sysinfo">JSONRPC_schema/schema-sysinfo.json</file>
         <file alias="schema-clear">JSONRPC_schema/schema-clear.json</file>
+        <file alias="schema-clearall">JSONRPC_schema/schema-clearall.json</file>
         <file alias="schema-adjustment">JSONRPC_schema/schema-adjustment.json</file>
         <file alias="schema-effect">JSONRPC_schema/schema-effect.json</file>
         <file alias="schema-create-effect">JSONRPC_schema/schema-create-effect.json</file>
@@ -17,5 +18,9 @@
         <file alias="schema-logging">JSONRPC_schema/schema-logging.json</file>
         <file alias="schema-processing">JSONRPC_schema/schema-processing.json</file>
         <file alias="schema-videomode">JSONRPC_schema/schema-videomode.json</file>
+        <!-- The following schemas are derecated but used to ensure backward compatibility with hyperion Classic remote control-->
+        <file alias="schema-transform">JSONRPC_schema/schema-hyperion-classic.json</file>
+        <file alias="schema-correction">JSONRPC_schema/schema-hyperion-classic.json</file>
+        <file alias="schema-temperature">JSONRPC_schema/schema-hyperion-classic.json</file>
     </qresource>
 </RCC>

libsrc/api/JsonAPI.cpp

@@ -13,6 +13,7 @@
 #include <QBuffer>
 #include <QByteArray>
 #include <QDateTime>
+#include <QHostInfo>
 
 // hyperion includes
 #include <utils/jsonschema/QJsonFactory.h>
@@ -104,6 +105,14 @@ void JsonAPI::handleMessage(const QString& messageString)
 	else if (command == "logging")        handleLoggingCommand       (message, command, tan);
 	else if (command == "processing")     handleProcessingCommand    (message, command, tan);
 	else if (command == "videomode")      handleVideoModeCommand     (message, command, tan);
+
+	// BEGIN | The following commands are derecated but used to ensure backward compatibility with hyperion Classic remote control
+	else if (command == "clearall")       handleClearallCommand(message, command, tan);
+	else if (command == "transform" || command == "correction" || command == "temperature")
+		sendErrorReply("The command " + command + "is deprecated, please use the Hyperion Web Interface to configure");
+	// END
+
+	// handle not implemented commands
 	else                                  handleNotImplemented       ();
 }
 
@@ -114,7 +123,7 @@ void JsonAPI::handleColorCommand(const QJsonObject& message, const QString& comm
 	// extract parameters
 	int priority = message["priority"].toInt();
 	int duration = message["duration"].toInt(-1);
-	QString origin = message["origin"].toString() + "@"+_peerAddress;
+	QString origin = message["origin"].toString("Empty") + "@"+_peerAddress;
 
 	std::vector<ColorRgb> colorData(_hyperion->getLedCount());
 	const QJsonArray & jsonColor = message["color"].toArray();
@@ -185,7 +194,7 @@ void JsonAPI::handleEffectCommand(const QJsonObject &message, const QString &com
 	int priority = message["priority"].toInt();
 	int duration = message["duration"].toInt(-1);
 	QString pythonScript = message["pythonScript"].toString();
-	QString origin = message["origin"].toString() + "@"+_peerAddress;
+	QString origin = message["origin"].toString("Empty") + "@"+_peerAddress;
 	const QJsonObject & effect = message["effect"].toObject();
 	const QString & effectName = effect["name"].toString();
 	const QString & data = message["imageData"].toString("").toUtf8();
@@ -463,6 +472,46 @@ void JsonAPI::handleServerInfoCommand(const QJsonObject& message, const QString&
 	}
 	info["sessions"] = sessions;
 
+	// BEGIN | The following entries are derecated but used to ensure backward compatibility with hyperion Classic remote control
+	// TODO Output the real transformation information instead of default
+
+		// host name
+		info["hostname"] = QHostInfo::localHostName();
+
+		// transform information (default values)
+		QJsonArray transformArray;
+		for (const QString& transformId : _hyperion->getAdjustmentIds())
+		{
+			QJsonObject transform;
+			QJsonArray blacklevel, whitelevel, gamma, threshold;
+
+			transform["id"] = transformId;
+			transform["saturationGain"] = 1.0;
+			transform["valueGain"]      = 1.0;
+			transform["saturationLGain"] = 1.0;
+			transform["luminanceGain"]   = 1.0;
+			transform["luminanceMinimum"]   = 0.0;
+
+			for (int i = 0; i < 3; i++ )
+			{
+				blacklevel.append(0.0);
+				whitelevel.append(1.0);
+				gamma.append(2.50);
+				threshold.append(0.0);
+			}
+
+			transform.insert("blacklevel", blacklevel);
+			transform.insert("whitelevel", whitelevel);
+			transform.insert("gamma", gamma);
+			transform.insert("threshold", threshold);
+
+			transformArray.append(transform);
+		}
+
+		info["transform"] = transformArray;
+
+	// END
+
 	sendSuccessDataReply(QJsonDocument(info), command, tan);
 
 	// AFTER we send the info, the client might want to subscribe to future updates
@@ -845,6 +894,16 @@ void JsonAPI::handleVideoModeCommand(const QJsonObject& message, const QString &
 	sendSuccessReply(command, tan);
 }
 
+void JsonAPI::handleClearallCommand(const QJsonObject& message, const QString& command, const int tan)
+{
+	emit forwardJsonMessage(message);
+
+	// clear priority
+	_hyperion->clearall();
+
+	// send reply
+	sendSuccessReply(command, tan);
+}
 
 void JsonAPI::handleNotImplemented()
 {

libsrc/jsonserver/JsonClientConnection.cpp

@@ -6,9 +6,13 @@
 #include <QTcpSocket>
 #include <QHostAddress>
 
+// websocket includes
+#include "webserver/WebSocketClient.h"
+
 JsonClientConnection::JsonClientConnection(QTcpSocket *socket)
 	: QObject()
 	, _socket(socket)
+	, _websocketClient(nullptr)
 	, _receiveBuffer()
 	, _log(Logger::getInstance("JSONCLIENTCONNECTION"))
 {
@@ -23,21 +27,37 @@ JsonClientConnection::JsonClientConnection(QTcpSocket *socket)
 void JsonClientConnection::readRequest()
 {
 	_receiveBuffer += _socket->readAll();
-	// raw socket data, handling as usual
+
-	int bytes = _receiveBuffer.indexOf('\n') + 1;
+	// might be an old hyperion classic handshake request or raw socket data
-	while(bytes > 0)
+	if(_receiveBuffer.contains("Upgrade: websocket"))
 	{
-		// create message string
+		if(_websocketClient == Q_NULLPTR)
-		QString message(QByteArray(_receiveBuffer.data(), bytes));
+		{
+			// disconnect this slot from socket for further requests
+			disconnect(_socket, &QTcpSocket::readyRead, this, &JsonClientConnection::readRequest);
+			int start = _receiveBuffer.indexOf("Sec-WebSocket-Key") + 19;
+			QByteArray header(_receiveBuffer.mid(start, _receiveBuffer.indexOf("\r\n", start) - start).data());
+			_websocketClient = new WebSocketClient(header, _socket, this);
+		}
+	}
+	else
+	{
+		// raw socket data, handling as usual
+		int bytes = _receiveBuffer.indexOf('\n') + 1;
+		while(bytes > 0)
+		{
+			// create message string
+			QString message(QByteArray(_receiveBuffer.data(), bytes));
 
-		// remove message data from buffer
+			// remove message data from buffer
-		_receiveBuffer = _receiveBuffer.mid(bytes);
+			_receiveBuffer = _receiveBuffer.mid(bytes);
 
-		// handle message
+			// handle message
-		_jsonAPI->handleMessage(message);
+			_jsonAPI->handleMessage(message);
 
-		// try too look up '\n' again
+			// try too look up '\n' again
-		bytes = _receiveBuffer.indexOf('\n') + 1;
+			bytes = _receiveBuffer.indexOf('\n') + 1;
+		}
 	}
 }
 

libsrc/jsonserver/JsonClientConnection.h

@@ -10,9 +10,10 @@
 
 class JsonAPI;
 class QTcpSocket;
+class WebSocketClient;
 
 ///
-/// The Connection object created by \a JsonServer when a new connection is establshed
+/// The Connection object created by \a JsonServer when a new connection is established
 ///
 class JsonClientConnection : public QObject
 {
@@ -41,6 +42,7 @@ private slots:
 
 private:
 	QTcpSocket* _socket;
+	WebSocketClient* _websocketClient;
 	/// new instance of JsonAPI
 	JsonAPI * _jsonAPI;
 

libsrc/webserver/QtHttpClientWrapper.cpp

@@ -4,8 +4,8 @@
 #include "QtHttpReply.h"
 #include "QtHttpServer.h"
 #include "QtHttpHeader.h"
-#include "WebSocketClient.h"
 #include "WebJsonRpc.h"
+#include "webserver/WebSocketClient.h"
 
 #include <QCryptographicHash>
 #include <QTcpSocket>
@@ -120,7 +120,7 @@ void QtHttpClientWrapper::onClientDataReceived (void) {
 						{
 							// disconnect this slot from socket for further requests
 							disconnect(m_sockClient, &QTcpSocket::readyRead, this, &QtHttpClientWrapper::onClientDataReceived);
-							m_websocketClient = new WebSocketClient(m_currentRequest, m_sockClient, this);
+							m_websocketClient = new WebSocketClient(m_currentRequest->getHeader(QtHttpHeader::SecWebSocketKey), m_sockClient, this);
 						}
 						break;
 					}

libsrc/webserver/WebSocketClient.cpp

@@ -1,4 +1,4 @@
-#include "WebSocketClient.h"
+#include "webserver/WebSocketClient.h"
 
 // hyperion includes
 #include <hyperion/Hyperion.h>
@@ -7,25 +7,23 @@
 #include <api/JsonAPI.h>
 
 // qt includes
-#include "QtHttpRequest.h"
-#include "QtHttpHeader.h"
 #include <QTcpSocket>
 #include <QtEndian>
 #include <QCryptographicHash>
 #include <QJsonObject>
+#include <QHostAddress>
 
-WebSocketClient::WebSocketClient(QtHttpRequest* request, QTcpSocket* sock, QObject* parent)
+
+WebSocketClient::WebSocketClient(QByteArray socketKey, QTcpSocket* sock, QObject* parent)
 	: QObject(parent)
 	, _socket(sock)
+	, _secWebSocketKey(socketKey)
 	, _log(Logger::getInstance("WEBSOCKET"))
-	, _hyperion(Hyperion::getInstance())
 {
 	// connect socket; disconnect handled from QtHttpServer
 	connect(_socket, &QTcpSocket::readyRead , this, &WebSocketClient::handleWebSocketFrame);
 
-	// QtHttpRequest contains all headers for handshake
+	const QString client = sock->peerAddress().toString();
-	QByteArray secWebSocketKey = request->getHeader(QtHttpHeader::SecWebSocketKey);
-	const QString client = request->getClientInfo().clientAddress.toString();
 
 	// Json processor
 	_jsonAPI = new JsonAPI(client, _log, this);
@@ -34,8 +32,8 @@ WebSocketClient::WebSocketClient(QtHttpRequest* request, QTcpSocket* sock, QObje
 	Debug(_log, "New connection from %s", QSTRING_CSTR(client));
 
 	// do handshake
-	secWebSocketKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+	_secWebSocketKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-	QByteArray hash = QCryptographicHash::hash(secWebSocketKey, QCryptographicHash::Sha1).toBase64();
+	QByteArray hash = QCryptographicHash::hash(_secWebSocketKey, QCryptographicHash::Sha1).toBase64();
 
 	QString data
 		= QString("HTTP/1.1 101 Switching Protocols\r\n")
@@ -225,6 +223,7 @@ void WebSocketClient::sendClose(int status, QString reason)
 	_socket->close();
 }
 
+/*
 void WebSocketClient::handleBinaryMessage(QByteArray &data)
 {
 	//uint8_t  priority   = data.at(0);
@@ -243,9 +242,10 @@ void WebSocketClient::handleBinaryMessage(QByteArray &data)
 	image.resize(width, height);
 
 	memcpy(image.memptr(), data.data()+4, imgSize);
-	//_hyperion->registerInput();
+	_hyperion->registerInput();
-	//_hyperion->setInputImage(priority, image, duration_s*1000);
+	_hyperion->setInputImage(priority, image, duration_s*1000);
 }
+*/
 
 qint64 WebSocketClient::sendMessage(QJsonObject obj)
 {

src/hyperion-remote/JsonConnection.cpp

@@ -587,7 +587,9 @@ QJsonObject JsonConnection::sendMessage(const QJsonObject & message)
 	QJsonDocument reply = QJsonDocument::fromJson(serializedReply ,&error);
 	if (error.error != QJsonParseError::NoError)
 	{
-		throw std::runtime_error("Error while parsing reply: invalid json");
+		throw std::runtime_error(
+			std::string("Error while parsing json reply: ") 
+			+ error.errorString().toStdString() );
 	}
 
 	return reply.object();