diff --git a/CMakeLists.txt b/CMakeLists.txt
index ed554110ce4abfcb8e07191a3ee06ed85b56c44d..e3b0fdf6d6a725164a040dc95088c922535c4faf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -30,3 +30,4 @@ find_package(
REQUIRED)
add_subdirectory(src)
+add_subdirectory(webchannel)
diff --git a/webchannel/CMakeLists.txt b/webchannel/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5df8bb47b29e500cfa0d1e9929785bb8fde668d5
--- /dev/null
+++ b/webchannel/CMakeLists.txt
@@ -0,0 +1,16 @@
+add_executable(
+ libmueb-webchannel
+ shared/websockettransport.h
+ shared/websocketclientwrapper.h
+ muebchannel.h
+ shared/websockettransport.cpp
+ shared/websocketclientwrapper.cpp
+ main.cc
+ muebchannel.cc)
+
+find_package(
+ Qt5
+ COMPONENTS WebChannel WebSockets Widgets
+ REQUIRED)
+target_link_libraries(libmueb-webchannel PRIVATE Qt5::Core Qt5::Gui Qt5::Widgets Qt5::WebChannel
+ Qt5::WebSockets muebtransmitter muebreceiver)
diff --git a/webchannel/index.html b/webchannel/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..330c4207ab196aa4fce7fb193cf0c12bb0bcd49e
--- /dev/null
+++ b/webchannel/index.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+ <meta charset="UTF-8">
+ <meta http-equiv="X-UA-Compatible" content="IE=edge">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <script type="text/javascript" src="./shared/qwebchannel.js"></script>
+ <script type="text/javascript">
+ //BEGIN SETUP
+ window.onload = function () {
+ if (location.search != "")
+ var baseUrl = (/[?&]webChannelBaseUrl=([A-Za-z0-9\-:/\.]+)/.exec(location.search)[1]);
+ else
+ var baseUrl = "ws://localhost:12345";
+
+ console.log("Connecting to WebSocket server at " + baseUrl + ".");
+ var socket = new WebSocket(baseUrl);
+
+ socket.onclose = function () {
+ console.error("web channel closed");
+ };
+ socket.onerror = function (error) {
+ console.error("web channel error: " + error);
+ };
+ socket.onopen = function () {
+ console.log("WebSocket connected, setting up QWebChannel.");
+ new QWebChannel(socket, function (channel) {
+ // make mueb_channel object accessible globally
+ window.mueb_channel = channel.objects.mueb_channel;
+
+ mueb_channel.SendFrame.connect(function (message) {
+ document.getElementById("image").src = message;
+ });
+
+ //mueb_channel.ReceiveFrame("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAaCAIAAABZ+cloAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH5QIUEgA5b0FMLwAAABl0RVh0Q29tbWVudABDcmVhdGVkIHdpdGggR0lNUFeBDhcAAAAlSURBVEjH7c1BAQAABASwo39nUvDaCqwmtzoCgUAgEAgEgpdgAdm7ATNLz2wUAAAAAElFTkSuQmCC");
+
+ console.log("Connected to WebChannel, ready to send/receive messages!");
+ });
+ }
+ }
+ //END SETUP
+ </script>
+ <title>Libmueb channel test</title>
+</head>
+
+<body>
+ <img id="image" width="320" height="260" style="image-rendering: pixelated;"></img>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/webchannel/main.cc b/webchannel/main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8629d48f7a3948fba8b99c2987ec9c76d0a06e70
--- /dev/null
+++ b/webchannel/main.cc
@@ -0,0 +1,33 @@
+#include <QApplication>
+#include <QWebChannel>
+#include <QWebSocketServer>
+
+#include "muebchannel.h"
+#include "shared/websocketclientwrapper.h"
+#include "shared/websockettransport.h"
+
+int main(int argc, char *argv[]) {
+ QApplication a(argc, argv);
+
+ // setup the QWebSocketServer
+ QWebSocketServer server(QStringLiteral("QWebChannel libmueb Server"),
+ QWebSocketServer::NonSecureMode);
+ if (!server.listen(QHostAddress::LocalHost, 12345)) {
+ qFatal("Failed to open web socket server.");
+ return 1;
+ }
+
+ // wrap WebSocket clients in QWebChannelAbstractTransport objects
+ WebSocketClientWrapper clientWrapper(&server);
+
+ // setup the channel
+ QWebChannel channel;
+ QObject::connect(&clientWrapper, &WebSocketClientWrapper::clientConnected,
+ &channel, &QWebChannel::connectTo);
+
+ // setup the MuebChannel and publish it to the QWebChannel
+ MuebChannel mueb_channel;
+ channel.registerObject(QStringLiteral("mueb_channel"), &mueb_channel);
+
+ return a.exec();
+}
diff --git a/webchannel/muebchannel.cc b/webchannel/muebchannel.cc
new file mode 100644
index 0000000000000000000000000000000000000000..410410103846dc15ca5f869cb2254055a9356edd
--- /dev/null
+++ b/webchannel/muebchannel.cc
@@ -0,0 +1,37 @@
+#include "muebchannel.h"
+
+#include <QBuffer>
+#include <QByteArray>
+#include <QDebug>
+#include <QString>
+
+MuebChannel::MuebChannel(QObject *parent)
+ : QObject(parent),
+ transmitter_(MuebTransmitter::Instance()),
+ receiver_(MuebReceiver::Instance()) {
+ connect(&receiver_, &MuebReceiver::FrameChanged, this,
+ &MuebChannel::FrameChanged);
+}
+
+void MuebChannel::ReceiveFrame(QString frame) {
+ auto idx = frame.indexOf(',');
+
+ if (idx > 0) {
+ frame = frame.mid(idx);
+ }
+
+ if (auto result = QByteArray::fromBase64Encoding(frame.toLatin1())) {
+ transmitter_.SendFrame(QImage::fromData(*result, "PNG"));
+ }
+}
+
+void MuebChannel::FrameChanged(QPixmap frame) {
+ QByteArray ba;
+ QBuffer buf(&ba);
+ buf.open(QIODevice::WriteOnly);
+ frame.save(&buf, "PNG");
+ QByteArray base64 = ba.toBase64().prepend("data:image/png;base64,");
+ buf.close();
+
+ emit SendFrame(base64);
+}
diff --git a/webchannel/muebchannel.h b/webchannel/muebchannel.h
new file mode 100644
index 0000000000000000000000000000000000000000..9cc6ba7944e0ef54a3a993f51bbd1df131518ea7
--- /dev/null
+++ b/webchannel/muebchannel.h
@@ -0,0 +1,41 @@
+#ifndef LIBMUEB_MUEBTRANSMITTERCHANNEL_H_
+#define LIBMUEB_MUEBTRANSMITTERCHANNEL_H_
+
+#include <QImage>
+#include <QObject>
+
+#include "muebreceiver.h"
+#include "muebtransmitter.h"
+
+/*
+ An instance of this class gets published over the WebChannel and is then
+ accessible to HTML clients.
+*/
+class MuebChannel : public QObject {
+ Q_OBJECT
+
+ public:
+ explicit MuebChannel(QObject* parent = nullptr);
+
+ signals:
+ /*
+ This signal is emitted from the C++ side and the text displayed on the
+ HTML client side.
+ */
+ void SendFrame(QString frame);
+
+ public slots:
+ /*
+ This slot is invoked from the HTML client side and the text displayed on
+ the server side.
+ */
+ void ReceiveFrame(QString frame);
+
+ private:
+ MuebTransmitter& transmitter_;
+ MuebReceiver& receiver_;
+
+ void FrameChanged(QPixmap frame);
+};
+
+#endif // LIBMUEB_MUEBTRANSMITTERCHANNEL_H_
diff --git a/webchannel/shared/qwebchannel.js b/webchannel/shared/qwebchannel.js
new file mode 100644
index 0000000000000000000000000000000000000000..32ad51eb7de524d5b7221e32711882d6d3d4957e
--- /dev/null
+++ b/webchannel/shared/qwebchannel.js
@@ -0,0 +1,448 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebChannel module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+"use strict";
+
+var QWebChannelMessageTypes = {
+ signal: 1,
+ propertyUpdate: 2,
+ init: 3,
+ idle: 4,
+ debug: 5,
+ invokeMethod: 6,
+ connectToSignal: 7,
+ disconnectFromSignal: 8,
+ setProperty: 9,
+ response: 10,
+};
+
+var QWebChannel = function(transport, initCallback)
+{
+ if (typeof transport !== "object" || typeof transport.send !== "function") {
+ console.error("The QWebChannel expects a transport object with a send function and onmessage callback property." +
+ " Given is: transport: " + typeof(transport) + ", transport.send: " + typeof(transport.send));
+ return;
+ }
+
+ var channel = this;
+ this.transport = transport;
+
+ this.send = function(data)
+ {
+ if (typeof(data) !== "string") {
+ data = JSON.stringify(data);
+ }
+ channel.transport.send(data);
+ }
+
+ this.transport.onmessage = function(message)
+ {
+ var data = message.data;
+ if (typeof data === "string") {
+ data = JSON.parse(data);
+ }
+ switch (data.type) {
+ case QWebChannelMessageTypes.signal:
+ channel.handleSignal(data);
+ break;
+ case QWebChannelMessageTypes.response:
+ channel.handleResponse(data);
+ break;
+ case QWebChannelMessageTypes.propertyUpdate:
+ channel.handlePropertyUpdate(data);
+ break;
+ default:
+ console.error("invalid message received:", message.data);
+ break;
+ }
+ }
+
+ this.execCallbacks = {};
+ this.execId = 0;
+ this.exec = function(data, callback)
+ {
+ if (!callback) {
+ // if no callback is given, send directly
+ channel.send(data);
+ return;
+ }
+ if (channel.execId === Number.MAX_VALUE) {
+ // wrap
+ channel.execId = Number.MIN_VALUE;
+ }
+ if (data.hasOwnProperty("id")) {
+ console.error("Cannot exec message with property id: " + JSON.stringify(data));
+ return;
+ }
+ data.id = channel.execId++;
+ channel.execCallbacks[data.id] = callback;
+ channel.send(data);
+ };
+
+ this.objects = {};
+
+ this.handleSignal = function(message)
+ {
+ var object = channel.objects[message.object];
+ if (object) {
+ object.signalEmitted(message.signal, message.args);
+ } else {
+ console.warn("Unhandled signal: " + message.object + "::" + message.signal);
+ }
+ }
+
+ this.handleResponse = function(message)
+ {
+ if (!message.hasOwnProperty("id")) {
+ console.error("Invalid response message received: ", JSON.stringify(message));
+ return;
+ }
+ channel.execCallbacks[message.id](message.data);
+ delete channel.execCallbacks[message.id];
+ }
+
+ this.handlePropertyUpdate = function(message)
+ {
+ message.data.forEach(data => {
+ var object = channel.objects[data.object];
+ if (object) {
+ object.propertyUpdate(data.signals, data.properties);
+ } else {
+ console.warn("Unhandled property update: " + data.object + "::" + data.signal);
+ }
+ });
+ channel.exec({type: QWebChannelMessageTypes.idle});
+ }
+
+ this.debug = function(message)
+ {
+ channel.send({type: QWebChannelMessageTypes.debug, data: message});
+ };
+
+ channel.exec({type: QWebChannelMessageTypes.init}, function(data) {
+ for (const objectName of Object.keys(data)) {
+ new QObject(objectName, data[objectName], channel);
+ }
+
+ // now unwrap properties, which might reference other registered objects
+ for (const objectName of Object.keys(channel.objects)) {
+ channel.objects[objectName].unwrapProperties();
+ }
+
+ if (initCallback) {
+ initCallback(channel);
+ }
+ channel.exec({type: QWebChannelMessageTypes.idle});
+ });
+};
+
+function QObject(name, data, webChannel)
+{
+ this.__id__ = name;
+ webChannel.objects[name] = this;
+
+ // List of callbacks that get invoked upon signal emission
+ this.__objectSignals__ = {};
+
+ // Cache of all properties, updated when a notify signal is emitted
+ this.__propertyCache__ = {};
+
+ var object = this;
+
+ // ----------------------------------------------------------------------
+
+ this.unwrapQObject = function(response)
+ {
+ if (response instanceof Array) {
+ // support list of objects
+ return response.map(qobj => object.unwrapQObject(qobj))
+ }
+ if (!(response instanceof Object))
+ return response;
+
+ if (!response["__QObject*__"] || response.id === undefined) {
+ var jObj = {};
+ for (const propName of Object.keys(response)) {
+ jObj[propName] = object.unwrapQObject(response[propName]);
+ }
+ return jObj;
+ }
+
+ var objectId = response.id;
+ if (webChannel.objects[objectId])
+ return webChannel.objects[objectId];
+
+ if (!response.data) {
+ console.error("Cannot unwrap unknown QObject " + objectId + " without data.");
+ return;
+ }
+
+ var qObject = new QObject( objectId, response.data, webChannel );
+ qObject.destroyed.connect(function() {
+ if (webChannel.objects[objectId] === qObject) {
+ delete webChannel.objects[objectId];
+ // reset the now deleted QObject to an empty {} object
+ // just assigning {} though would not have the desired effect, but the
+ // below also ensures all external references will see the empty map
+ // NOTE: this detour is necessary to workaround QTBUG-40021
+ Object.keys(qObject).forEach(name => delete qObject[name]);
+ }
+ });
+ // here we are already initialized, and thus must directly unwrap the properties
+ qObject.unwrapProperties();
+ return qObject;
+ }
+
+ this.unwrapProperties = function()
+ {
+ for (const propertyIdx of Object.keys(object.__propertyCache__)) {
+ object.__propertyCache__[propertyIdx] = object.unwrapQObject(object.__propertyCache__[propertyIdx]);
+ }
+ }
+
+ function addSignal(signalData, isPropertyNotifySignal)
+ {
+ var signalName = signalData[0];
+ var signalIndex = signalData[1];
+ object[signalName] = {
+ connect: function(callback) {
+ if (typeof(callback) !== "function") {
+ console.error("Bad callback given to connect to signal " + signalName);
+ return;
+ }
+
+ object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || [];
+ object.__objectSignals__[signalIndex].push(callback);
+
+ // only required for "pure" signals, handled separately for properties in propertyUpdate
+ if (isPropertyNotifySignal)
+ return;
+
+ // also note that we always get notified about the destroyed signal
+ if (signalName === "destroyed" || signalName === "destroyed()" || signalName === "destroyed(QObject*)")
+ return;
+
+ // and otherwise we only need to be connected only once
+ if (object.__objectSignals__[signalIndex].length == 1) {
+ webChannel.exec({
+ type: QWebChannelMessageTypes.connectToSignal,
+ object: object.__id__,
+ signal: signalIndex
+ });
+ }
+ },
+ disconnect: function(callback) {
+ if (typeof(callback) !== "function") {
+ console.error("Bad callback given to disconnect from signal " + signalName);
+ return;
+ }
+ object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || [];
+ var idx = object.__objectSignals__[signalIndex].indexOf(callback);
+ if (idx === -1) {
+ console.error("Cannot find connection of signal " + signalName + " to " + callback.name);
+ return;
+ }
+ object.__objectSignals__[signalIndex].splice(idx, 1);
+ if (!isPropertyNotifySignal && object.__objectSignals__[signalIndex].length === 0) {
+ // only required for "pure" signals, handled separately for properties in propertyUpdate
+ webChannel.exec({
+ type: QWebChannelMessageTypes.disconnectFromSignal,
+ object: object.__id__,
+ signal: signalIndex
+ });
+ }
+ }
+ };
+ }
+
+ /**
+ * Invokes all callbacks for the given signalname. Also works for property notify callbacks.
+ */
+ function invokeSignalCallbacks(signalName, signalArgs)
+ {
+ var connections = object.__objectSignals__[signalName];
+ if (connections) {
+ connections.forEach(function(callback) {
+ callback.apply(callback, signalArgs);
+ });
+ }
+ }
+
+ this.propertyUpdate = function(signals, propertyMap)
+ {
+ // update property cache
+ for (const propertyIndex of Object.keys(propertyMap)) {
+ var propertyValue = propertyMap[propertyIndex];
+ object.__propertyCache__[propertyIndex] = this.unwrapQObject(propertyValue);
+ }
+
+ for (const signalName of Object.keys(signals)) {
+ // Invoke all callbacks, as signalEmitted() does not. This ensures the
+ // property cache is updated before the callbacks are invoked.
+ invokeSignalCallbacks(signalName, signals[signalName]);
+ }
+ }
+
+ this.signalEmitted = function(signalName, signalArgs)
+ {
+ invokeSignalCallbacks(signalName, this.unwrapQObject(signalArgs));
+ }
+
+ function addMethod(methodData)
+ {
+ var methodName = methodData[0];
+ var methodIdx = methodData[1];
+
+ // Fully specified methods are invoked by id, others by name for host-side overload resolution
+ var invokedMethod = methodName[methodName.length - 1] === ')' ? methodIdx : methodName
+
+ object[methodName] = function() {
+ var args = [];
+ var callback;
+ var errCallback;
+ for (var i = 0; i < arguments.length; ++i) {
+ var argument = arguments[i];
+ if (typeof argument === "function")
+ callback = argument;
+ else if (argument instanceof QObject && webChannel.objects[argument.__id__] !== undefined)
+ args.push({
+ "id": argument.__id__
+ });
+ else
+ args.push(argument);
+ }
+
+ var result;
+ // during test, webChannel.exec synchronously calls the callback
+ // therefore, the promise must be constucted before calling
+ // webChannel.exec to ensure the callback is set up
+ if (!callback && (typeof(Promise) === 'function')) {
+ result = new Promise(function(resolve, reject) {
+ callback = resolve;
+ errCallback = reject;
+ });
+ }
+
+ webChannel.exec({
+ "type": QWebChannelMessageTypes.invokeMethod,
+ "object": object.__id__,
+ "method": invokedMethod,
+ "args": args
+ }, function(response) {
+ if (response !== undefined) {
+ var result = object.unwrapQObject(response);
+ if (callback) {
+ (callback)(result);
+ }
+ } else if (errCallback) {
+ (errCallback)();
+ }
+ });
+
+ return result;
+ };
+ }
+
+ function bindGetterSetter(propertyInfo)
+ {
+ var propertyIndex = propertyInfo[0];
+ var propertyName = propertyInfo[1];
+ var notifySignalData = propertyInfo[2];
+ // initialize property cache with current value
+ // NOTE: if this is an object, it is not directly unwrapped as it might
+ // reference other QObject that we do not know yet
+ object.__propertyCache__[propertyIndex] = propertyInfo[3];
+
+ if (notifySignalData) {
+ if (notifySignalData[0] === 1) {
+ // signal name is optimized away, reconstruct the actual name
+ notifySignalData[0] = propertyName + "Changed";
+ }
+ addSignal(notifySignalData, true);
+ }
+
+ Object.defineProperty(object, propertyName, {
+ configurable: true,
+ get: function () {
+ var propertyValue = object.__propertyCache__[propertyIndex];
+ if (propertyValue === undefined) {
+ // This shouldn't happen
+ console.warn("Undefined value in property cache for property \"" + propertyName + "\" in object " + object.__id__);
+ }
+
+ return propertyValue;
+ },
+ set: function(value) {
+ if (value === undefined) {
+ console.warn("Property setter for " + propertyName + " called with undefined value!");
+ return;
+ }
+ object.__propertyCache__[propertyIndex] = value;
+ var valueToSend = value;
+ if (valueToSend instanceof QObject && webChannel.objects[valueToSend.__id__] !== undefined)
+ valueToSend = { "id": valueToSend.__id__ };
+ webChannel.exec({
+ "type": QWebChannelMessageTypes.setProperty,
+ "object": object.__id__,
+ "property": propertyIndex,
+ "value": valueToSend
+ });
+ }
+ });
+
+ }
+
+ // ----------------------------------------------------------------------
+
+ data.methods.forEach(addMethod);
+
+ data.properties.forEach(bindGetterSetter);
+
+ data.signals.forEach(function(signal) { addSignal(signal, false); });
+
+ Object.assign(object, data.enums);
+}
+
+//required for use with nodejs
+if (typeof module === 'object') {
+ module.exports = {
+ QWebChannel: QWebChannel
+ };
+}
diff --git a/webchannel/shared/websocketclientwrapper.cpp b/webchannel/shared/websocketclientwrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..16be85e3ef433fe6296e5f76093eb45b8711934d
--- /dev/null
+++ b/webchannel/shared/websocketclientwrapper.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebChannel module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of The Qt Company Ltd nor the names of its
+** contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "websocketclientwrapper.h"
+#include "websockettransport.h"
+
+#include <QWebSocketServer>
+
+/*!
+ \brief Wraps connected QWebSockets clients in WebSocketTransport objects.
+
+ This code is all that is required to connect incoming WebSockets to the WebChannel. Any kind
+ of remote JavaScript client that supports WebSockets can thus receive messages and access the
+ published objects.
+*/
+
+/*!
+ Construct the client wrapper with the given parent.
+
+ All clients connecting to the QWebSocketServer will be automatically wrapped
+ in WebSocketTransport objects.
+*/
+WebSocketClientWrapper::WebSocketClientWrapper(QWebSocketServer *server, QObject *parent)
+ : QObject(parent)
+ , m_server(server)
+{
+ connect(server, &QWebSocketServer::newConnection,
+ this, &WebSocketClientWrapper::handleNewConnection);
+}
+
+/*!
+ Wrap an incoming WebSocket connection in a WebSocketTransport object.
+*/
+void WebSocketClientWrapper::handleNewConnection()
+{
+ emit clientConnected(new WebSocketTransport(m_server->nextPendingConnection()));
+}
diff --git a/webchannel/shared/websocketclientwrapper.h b/webchannel/shared/websocketclientwrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..efb8b4b0d1f87610308b99a81d674156dae1f120
--- /dev/null
+++ b/webchannel/shared/websocketclientwrapper.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebChannel module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of The Qt Company Ltd nor the names of its
+** contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef WEBSOCKETCLIENTWRAPPER_H
+#define WEBSOCKETCLIENTWRAPPER_H
+
+#include <QObject>
+
+class WebSocketTransport;
+
+QT_BEGIN_NAMESPACE
+class QWebSocketServer;
+QT_END_NAMESPACE
+
+class WebSocketClientWrapper : public QObject
+{
+ Q_OBJECT
+
+public:
+ WebSocketClientWrapper(QWebSocketServer *server, QObject *parent = nullptr);
+
+signals:
+ void clientConnected(WebSocketTransport *client);
+
+private slots:
+ void handleNewConnection();
+
+private:
+ QWebSocketServer *m_server;
+};
+
+#endif // WEBSOCKETCLIENTWRAPPER_H
diff --git a/webchannel/shared/websockettransport.cpp b/webchannel/shared/websockettransport.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e4ce50a3cd451d1bcd5588c19228ab8f0e99067c
--- /dev/null
+++ b/webchannel/shared/websockettransport.cpp
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebChannel module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of The Qt Company Ltd nor the names of its
+** contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "websockettransport.h"
+
+#include <QDebug>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QWebSocket>
+
+/*!
+ \brief QWebChannelAbstractSocket implementation that uses a QWebSocket internally.
+
+ The transport delegates all messages received over the QWebSocket over its
+ textMessageReceived signal. Analogously, all calls to sendTextMessage will
+ be send over the QWebSocket to the remote client.
+*/
+
+/*!
+ Construct the transport object and wrap the given socket.
+
+ The socket is also set as the parent of the transport object.
+*/
+WebSocketTransport::WebSocketTransport(QWebSocket *socket)
+: QWebChannelAbstractTransport(socket)
+, m_socket(socket)
+{
+ connect(socket, &QWebSocket::textMessageReceived,
+ this, &WebSocketTransport::textMessageReceived);
+ connect(socket, &QWebSocket::disconnected,
+ this, &WebSocketTransport::deleteLater);
+}
+
+/*!
+ Destroys the WebSocketTransport.
+*/
+WebSocketTransport::~WebSocketTransport()
+{
+ m_socket->deleteLater();
+}
+
+/*!
+ Serialize the JSON message and send it as a text message via the WebSocket to the client.
+*/
+void WebSocketTransport::sendMessage(const QJsonObject &message)
+{
+ QJsonDocument doc(message);
+ m_socket->sendTextMessage(QString::fromUtf8(doc.toJson(QJsonDocument::Compact)));
+}
+
+/*!
+ Deserialize the stringified JSON messageData and emit messageReceived.
+*/
+void WebSocketTransport::textMessageReceived(const QString &messageData)
+{
+ QJsonParseError error;
+ QJsonDocument message = QJsonDocument::fromJson(messageData.toUtf8(), &error);
+ if (error.error) {
+ qWarning() << "Failed to parse text message as JSON object:" << messageData
+ << "Error is:" << error.errorString();
+ return;
+ } else if (!message.isObject()) {
+ qWarning() << "Received JSON message that is not an object: " << messageData;
+ return;
+ }
+ emit messageReceived(message.object(), this);
+}
diff --git a/webchannel/shared/websockettransport.h b/webchannel/shared/websockettransport.h
new file mode 100644
index 0000000000000000000000000000000000000000..252eaebe07ff032da0685984201972359c3eee88
--- /dev/null
+++ b/webchannel/shared/websockettransport.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebChannel module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of The Qt Company Ltd nor the names of its
+** contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef WEBSOCKETTRANSPORT_H
+#define WEBSOCKETTRANSPORT_H
+
+#include <QWebChannelAbstractTransport>
+
+QT_BEGIN_NAMESPACE
+class QWebSocket;
+QT_END_NAMESPACE
+
+class WebSocketTransport : public QWebChannelAbstractTransport
+{
+ Q_OBJECT
+public:
+ explicit WebSocketTransport(QWebSocket *socket);
+ virtual ~WebSocketTransport();
+
+ void sendMessage(const QJsonObject &message) override;
+
+private slots:
+ void textMessageReceived(const QString &message);
+
+private:
+ QWebSocket *m_socket;
+};
+
+#endif // WEBSOCKETTRANSPORT_H