UpLowLimp/ZBD_IIIDL_S_Project/Src/TrainManager/QmlTcpSocket/TcpSocket.cpp

/*
 * Copyright (C) 2016 EPFL
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see http://www.gnu.org/licenses/.
 */

/**
 * @file TcpSocket.cpp
 * @brief QML wrapper source for QTcpSocket
 * @author Ayberk Özgür
 * @date 2016-11-10
 */

#include "TcpSocket.h"

#include <QHostAddress>

namespace QMLTcpSockets
{

    TcpSocket::TcpSocket(QQuickItem *parent):
        QQuickItem(parent),
        socket(this)
    {
        connect(&socket, SIGNAL(connected()), this, SIGNAL(connected()));
        connect(&socket, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
        connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(emitErrorAsInt(QAbstractSocket::SocketError)));
        connect(&socket, SIGNAL(readyRead()), this, SLOT(publish()));
        peer = "";
        port = 0;
    }

    TcpSocket::TcpSocket(QIntPtr *socketDescriptor, QQuickItem *parent):
        TcpSocket(parent)
    {
        socket.setSocketDescriptor(socketDescriptor->ptr);
        socketDescriptor->deleteLater();
        peer = socket.peerAddress().toString();
        port = socket.peerPort();
    }

    TcpSocket::~TcpSocket()
    {
        socket.flush();
    }

    void TcpSocket::setSocketDescriptor(QIntPtr *socketDescriptor)
    {
        socket.flush();
        socket.disconnectFromHost();

        socket.setSocketDescriptor(socketDescriptor->ptr);
        socketDescriptor->deleteLater();

        QString peer = socket.peerAddress().toString();
        if(this->peer != peer)
        {
            this->peer = peer;
            emit peerChanged();
        }

        quint16 port = socket.peerPort();
        if(this->port != port)
        {
            this->port = port;
            emit portChanged();
        }

        emit connected();
    }

    void TcpSocket::setSocketOption(int option, QVariant value)
    {
        socket.setSocketOption((QAbstractSocket::SocketOption)option, value);
    }

    void TcpSocket::setPeer(QString peer)
    {
        if(peer != this->peer)
        {
            if(socket.state() != TcpSocketEnums::UnconnectedState)
            {
                qWarning() << "TcpSocket::setPeer(): Can only set peer while disconnected.";
            }
            else
            {
                this->peer = peer;
                emit peerChanged();
            }
        }
    }

    void TcpSocket::setPort(int port)
    {
        if(port < 0)
        {
            qWarning() << "TcpSocket::setPort(): port given was negative, setting to 0.";
            port = 0;
        }
        else if(port > 0xFFFF)
        {
            qWarning() << "TcpSocket::setPort(): port given was larger than 65535, setting to 65535.";
            port = 0xFFFF;
        }

        if(port != this->port)
        {
            if(socket.state() != TcpSocketEnums::UnconnectedState)
            {
                qWarning() << "TcpSocket::setPort(): Can only set port while disconnected.";
            }
            else
            {
                this->port = port;
                emit portChanged();
            }
        }
    }

    void TcpSocket::connectToHost()
    {
        socket.connectToHost(peer, port);
    }

    void TcpSocket::disconnectFromHost()
    {
        socket.disconnectFromHost();
    }

    void TcpSocket::emitErrorAsInt(QAbstractSocket::SocketError socketError)
    {
        emit error(socketError);
    }

    void TcpSocket::publish()
    {
        QList<int> list;
        QByteArray receivedBytes = socket.readAll();
        for(char c : receivedBytes)
        {
            list << (int)(*((unsigned char *)(&c)));
        }
        emit bytesReceived(list);
    }

    bool TcpSocket::writeBytes(QList<int> bytes)
    {
        QByteArray container;
        for(int b : bytes)
        {
            if(b < 0 || b > 0xFF)
            {
                qWarning() << "TcpSocket::writeBytes(): bytes contain integer not in [0x00,0xFF], not writing";
                return false;
            }
            else
            {
                container.append((char)b);
            }
        }

        int numBytesToWrite = container.size();
        const char *bytesRaw = container.constData();
        while(numBytesToWrite > 0)
        {
            int bytesWritten = socket.write(bytesRaw, numBytesToWrite);
            if(bytesWritten < 0)
            {
                qWarning() << "TcpSocket::writeBytes(): Bytes were not written: " << socket.errorString();
                return false;
            }
            numBytesToWrite -= bytesWritten;
            bytesRaw += bytesWritten;
        }
        socket.flush();

        return true;
    }

}