aswi2021virtual-surreality-gitlab/deltarobot/curvedataserver.h @ 207b75a4

#ifndef CURVEDATASERVER_H
#define CURVEDATASERVER_H

#include <QObject>
#include <QTcpServer>
#include <QTcpSocket>
#include <map>
#include <mutex>
#include <thread>


/**
 * Manages communication with clients who can connect to the server in order to receive real-time data about the current
 * exercise. The served data may be used e.g. for external visualization. A reference implementation of such a client is
 * the deltarobot-vr Unity application.
 */
class CurveDataServer : QObject
{
    Q_OBJECT

public:

    /**
     * Holds information about a client, its Qt socket, data buffer etc.
     */
    struct Client {
        /**
         * Size of the client buffer.
         *
         * @note Current implementation truncates any variable-length messages longer than what would fit in the buffer.
         */
        static const size_t BUF_SIZE = 4096;

        static const size_t MESSAGE_ID_SIZE = sizeof(uint16_t);      ///< Size of the protocol message identifier
        static const size_t MESSAGE_LENGTH_SIZE = sizeof(uint32_t);  ///< Size of the variable-length message's content length

        QTcpSocket* socket;                 ///< Communication socket
        std::map<uint64_t, uint64_t> ping;  ///< Key: ping ID;  Value: ping timestamp (msec);
        uint64_t latency;                   ///< Current latency
        uint64_t lastPong;                  ///< Timestamp of the last pong

        char buf[BUF_SIZE];                 ///< Message buffer
        size_t bufUsed = 0;                 ///< Number of bytes used up in the message buffer

        bool magic = false;                 ///< Whether the client has sent the correct protocol magic
        bool version = false;               ///< Whether the client has sent the correct protocol version
        bool protocolValid = false;         ///< Whether the client has sent both the correct protocol magic and version.

        bool initialized = false;           ///< Whether the server has initialized this client with the current curve

        Client(QTcpSocket* socket);
    };

    explicit CurveDataServer(quint16 port = 4242);
    ~CurveDataServer();

    /** Sends the current actuator position. */
    void sendActuatorPosition(float x, float y, float z);

    /** Sends the actual direction the actuator is moving in. */
    void sendActualDirection(float x, float y, float z);

    /** Sends the direction the actuator *should* be moving in, in order to draw the curve. */
    void sendTargetDirection(float x, float y, float z);

    /** Stores and sends the specified curve. */
    void sendNewCurve(QList<QVector4D> &points);

    /** Stores and sends the specified curve. */
    void sendNewCurve(QList<QVector3D> &points);

    /** Sends the currently stored curve. This is used for newly connected clients. */
    void sendCurve(Client &client);

    /** Sends ping messages to the clients, checks whether any clients have timed out, and disconnects any that have. */
    void processPings();

public slots:
    void onNewConnection();
    void onSocketStateChanged(QAbstractSocket::SocketState socketState);
    void onReadyRead();

private:
    /** Gets the client that is connected via the specified socket. */
    QList<Client>::iterator clientOf(QTcpSocket *socket);

    void handleMessage(Client& client, uint16_t messageId, void* content, size_t contentSize);
    void handleProtocolMagic(Client& client, char* content);
    void handleVersion(Client& client, uint8_t content);
    void handlePong(Client& client, uint64_t* content);
    void handleEOT(Client& client, char* content, size_t contentSize);

    /**
     * Checks whether the specified client has already sent both its protocol magic and version. If so, the appropriate
     * flag is set and a log is written out into qDebug.
     */
    void validateProtocol(Client& client);

    void removeSocket(QTcpSocket *socket);
    void terminateConnection(Client& client, std::string&& reason);
    void sendPing(Client& client);

    void sendPreamble(QTcpSocket *socket);
    void sendProtocolMagic(QTcpSocket *socket);
    void sendVersion(QTcpSocket *socket);
    void sendEot(QTcpSocket *socket, std::string&& message);

    void sendMessageToAllConnected(QByteArray &message);

    QTcpServer _server;

    std::recursive_mutex _socketsLock;
    QList<Client> _sockets;

    std::recursive_mutex _currentCurveLock;
    QList<QVector3D> _currentCurve;
};

#endif // CURVEDATASERVER_H