Page History

 #include "tcp_client.h"

TCPClient::TCPClient()
{
    /// Muodostetaan QxtRPCPeer-luokasta olio
    client = new QxtRPCPeer();

    /// Oletus IP, johon yhdistetään mikäli käyttäjä ei syötä IP:tä
    hostIp = "127.0.0.1";

    /// Oletusportti johon yhdistetään
    hostPort = 45123;

    /// Ollaanko yhteydessä? Oletuksena false
    connected = false;

    /// Jotta signaaleihin voidaan yhdistää QVector-tyyppisiä parametreja, on ne määrittettävä seuraavasti
    qRegisterMetaTypeStreamOperators< QVector<QString> >("QVector<QString>");

    /// Liitetään signaalit slotteihin
    connect(this->client, SIGNAL(connectedToServer()), this, SLOT(connectionEstablished()));
    connect(this->client, SIGNAL(serverError(QAbstractSocket::SocketError)), this, SLOT(connectionError()));

    /// attachSignal-funktio kapseloi signaalin muotoon, jossa se voidaan lähettää verkkoyhteyden yli
    /// Funktion QString-parametri on tunniste, jolla signaali tunnistetaan serverin puolella ja
    /// pystytään yhdistämään tiettyyn slottiin.
    client->attachSignal(this, SIGNAL(sendSignal(QVector<QString>)), QString("signal1"))signalToServer"));

    /// attachSlot-funktio vastaanottaa kapseloidun signaalin, jonka receiveData-slot ottaa vastaan
    client->attachSlot(QString("signalFromServer"), this, SLOT(receiveData(QVector<QString>)));
}
TCPClient::~TCPClient()
{
    /// Poistetaan muodostettu olio muistin säästämiseksi
    delete client;
}

/// Yhdistetään serveriin oletusarvoilla tai käyttäjän antamilla arvoilla
void TCPClient::connectToServer()
{
    /// Connect metodi muodostaa connectedToServer- tai serverError-signaalin
    client->connect(this->hostIp, this->hostPort);
}
void TCPClient::connectToServer(QString ip, int port)
{
    client->connect(ip, port);
}
void TCPClient::disconnectFromServer()
{
    client->disconnectServer();
    connected = false;
}

void TCPClient::sendData(QVector<QString> data)
{
    emit sendSignal(data);
}
void TCPClient::receiveData(QVector<QString>)
{
    qDebug() << "message from server";
}

void TCPClient::connectionEstablished()
{
    connected = true;
    qDebug() << "connected";
}
void TCPClient::connectionError()
{
    qDebug() << "connection error";
}

#ifndef TCP_SERVER_H
#define TCP_SERVER_H

#include <QxtNetwork/qxtrpcpeer.h>

class TCPServer : public QObject
{
    Q_OBJECT
public:
    TCPServer();
    ~TCPServer();

    void startServer();
    void startServer(QHostAddress, int);
    void stopServer();

private:
    QxtRPCPeer *server;
    QHostAddress serverIp;
    int serverPort;
    QList<quint64> clients;

signals:
    void clientConnected(quint64);
    void clientDisconnected(quint64);
    void sendSignal(QVector<QString>);

private slots:
    void newClient(quint64);
    void deleteClient(quint64);
    void receiveSignal(quint64, QVector<QString>);
};

#endif // TCP_SERVER_H

#include "tcp_server.h"

TCPServer::TCPServer()
{
    server = new QxtRPCPeer();
    serverIp = QHostAddress::Any;
    serverPort = 45123;

    qRegisterMetaTypeStreamOperators< QVector<QString> >("QVector<QString>");
    server->attachSlot(QString("signal1signalToServer"), this, SLOT(receiveSignal(quint64, QVector<QString>)));

       server->attachSignal(this, SIGNAL(sendSignal(QVector<QString>)), QString("signalFromServer"));

    connect(this->server, SIGNAL(clientConnected(quint64)), this, SLOT(newClient(quint64)));
       connect(this->server, SIGNAL(clientDisconnected(quint64)), this, SLOT(deleteClient(quint64)));
}
TCPServer::~TCPServer()
{
    delete server;
}
void TCPServer::startServer()
{
    server->listen(this->serverIp, this->serverPort);

    qDebug() << "server up";
}
void TCPServer::startServer(QHostAddress address, int port)
{
    server->listen(address, port);

    qDebug() << "server up";
}
void TCPServer::stopServer()
{
    server->stopListening();
    clients.empty();

    qDebug() << "server down";
}

void TCPServer::newClient(quint64 clientId)
{
    clients.append(clientId);

    qDebug() << clientId << " connected";
}
void TCPServer::deleteClient(quint64 clientId)
{
    int delClient = clients.indexOf(clientId);
    clients.removeAt(delClient);

    qDebug() << clientId << " disconnected";
}

void TCPServer::receiveSignal(quint64 connectionId, QVector<QString> data)
{
    // Tee jotain data:lle

    // Lähetetään tietoa serverin tilasta takaisin käyttäjälle
    // emit sendSignal(vector);
}