SoundBand/sync/ETcpSocket.cpp

#include "ETcpSocket.h"
#include "exaptions.h"
#include <QTimer>

ETcpSocket::ETcpSocket()
{
    source=new QTcpSocket();
    init();
}
ETcpSocket::ETcpSocket(QTcpSocket*ptr)
{
    source=ptr;
    init();
    pingTimer->start(0);
}

ETcpSocket::ETcpSocket(const QString& address, int port){
    source = new QTcpSocket();
    source->connectToHost(address, port);
    if(!source->waitForConnected(DEEP_SCANER_INTERVAL) || !source->open(QIODevice::ReadWrite)){
        throw AddNodeExaption();
    }
    init();
}

void ETcpSocket::init(){
    array = new QByteArray;
    fSynced = false;
    differenceTime = 0;
    pingTimer = new QTimer();
    checInterval = CHECK_PING_INTERVAL;

    srand(time(0));

    connect(pingTimer, SIGNAL(timeout()), SLOT(calcPing()));
    connect(source,SIGNAL(connected()),this,SLOT(connected_()));
    connect(source,SIGNAL(disconnected()),this,SLOT(disconnected_()));
    connect(source,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(error_(QAbstractSocket::SocketError)));
    connect(source,SIGNAL(hostFound()),this,SLOT(hostFound_()));
    connect(source,SIGNAL(proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *)),this,SLOT(proxyAuthenticationRequired_(const QNetworkProxy &, QAuthenticator *)));
    connect(source,SIGNAL(stateChanged(QAbstractSocket::SocketState)),this,SLOT(stateChanged_(QAbstractSocket::SocketState)));
    connect(source,SIGNAL(readyRead()),this,SLOT(readReady_()));
}

/**
 * @todo remove from array is sloy
*/

bool ETcpSocket::readDriverFlags(const driver_flag driverFlag){

    if(driverFlag & CALIBRATION_SENDER){
        milliseconds ms;

        source->read((char*)(&ms), sizeof(ms));

        milliseconds range = ChronoTime::now() - ms;

        QByteArray cArray;
        QDataStream stream(&cArray,QIODevice::ReadWrite);

        char answer = IS_DRIVER;
        if(range < MIN_DIFFERENCE){
            answer = CALIBRATION_RECEIVER_DONE | answer;
            fSynced = true;

        }else{
            answer = CALIBRATION_RECEIVER | answer;
            stream << range;

        }

        source->write(cArray, answer);

    }

    if(driverFlag & CALIBRATION_RECEIVER){
        ping = ChronoTime::now() - lastTime;
        milliseconds ms;

        if(sizeof(ms) != source->read((char*)(&ms), sizeof(ms))){
            return false;
        }

        differenceTime += ms + ping / 2;

        QByteArray cArray;

        QDataStream stream(&cArray, QIODevice::ReadWrite);
        stream << milliseconds(ChronoTime::now() + differenceTime);

        lastTime = ChronoTime::now();
        source->write(cArray, CALIBRATION_SENDER | IS_DRIVER);
    }

    if(driverFlag & CALIBRATION_RECEIVER_DONE){
        QByteArray cArray;
        QDataStream stream(&cArray, QIODevice::ReadWrite);

        stream << milliseconds(-differenceTime);
        fSynced = true;

        source->write(cArray, CALIBRATION_SENDER_DONE | IS_DRIVER);
    }

    if(driverFlag & CALIBRATION_SENDER_DONE){

        if(sizeof(differenceTime) !=
                source->read((char*)differenceTime, sizeof(differenceTime))){
            return false;
        }

    }

    if(driverFlag & CALIBRATION_PING_DONE){
        ping = ChronoTime::now() - lastTime;

    }

    if(driverFlag & CALIBRATION_PING){
        calcPing(CALIBRATION_PING_DONE | IS_DRIVER);

    }

    if(source->readAll().size()){
        return false;
    }
    return true;

}


bool ETcpSocket::driver(){

    driver_flag driverFlag;
    source->read((char*)&driverFlag, 1);

    if(driverFlag & IS_DRIVER){

        if(!readDriverFlags(driverFlag)){
            throw NetworkError();
            source->close();
        }

        return false;
    }

    return true;

}

int ETcpSocket::getPing()const{
    return ping;
}

void ETcpSocket::calcPing(driver_flag flag){
    pingTimer->setInterval(rand() % checInterval);
    lastTime = ChronoTime::now();

    Write(QByteArray(), flag);
}

void ETcpSocket::setCheckInterval(int newInterval){
    checInterval = newInterval;
}

int ETcpSocket::getCheckInterval()const{
    return checInterval;
}

void ETcpSocket::error_(QAbstractSocket::SocketError i){
    emit Error(this,i);
}

void ETcpSocket::connected_(){
    pingTimer->start(0);
    emit Connected(this);
}

void ETcpSocket::disconnected_(){
    emit Disconnected(this);
}

void ETcpSocket::hostFound_(){
    emit HostFound(this);
}

void ETcpSocket::proxyAuthenticationRequired_(const QNetworkProxy &proxy, QAuthenticator *authenticator){
    emit ProxyAuthenticationRequired(this, proxy, authenticator);
}

void ETcpSocket::stateChanged_(QAbstractSocket::SocketState socketState){
    emit StateChanged(this,socketState);
}

void ETcpSocket::readReady_(){

    if(!driver())
        return ;

    bool sizewrite = array->isEmpty();
    array->append(source->readAll());
    QDataStream stream(array, QIODevice::ReadOnly);
    if(sizewrite)
        stream >> size;

#ifdef QT_DEBUG
    qDebug()<<"messae size:" << size;
    qDebug()<<"message package size:" << array->size();
#endif
    if(size==array->size())
    {
        array->remove(0, sizeof(qint32));
        ReadyStack.push_back(array);
        array=new QByteArray();
        emit Message(this);
    }else{
        emit donwload(array->size(), size);
    }
}

QString ETcpSocket::peerName() const{
    return QString("%0:%1").arg(source->peerAddress().toString()).arg(source->peerPort());
}

QString ETcpSocket::localName() const{
    return QString("%0:%1").arg(source->localAddress().toString()).arg(source->localPort());
}

QByteArray* ETcpSocket::topStack(){
    if(ReadyStack.size())
        return ReadyStack.front();
    return NULL;
}

QTcpSocket* ETcpSocket::getSource()const{
    return source;
}

void ETcpSocket::nextItem(bool free){
    if( ReadyStack.size()){
        if(free){
            ReadyStack.front()->clear();
            delete ReadyStack.front();
        }
        ReadyStack.pop_front();
    }
}

int ETcpSocket::sizeDescriptPackege(){
    return sizeof(qint32);
}

QString ETcpSocket::toStringTcp(){
    return source->peerAddress().toString();
}

milliseconds ETcpSocket::getDifferenceTime() const{
    return differenceTime;
}

bool ETcpSocket::isSynced()const{
    return fSynced;
}

bool ETcpSocket::Write(const QByteArray&data , signed char driverFlag){
    if(source->state()==QTcpSocket::ConnectedState){
       QByteArray array;
       QDataStream stream(&array, QIODevice::ReadWrite);

       stream << driverFlag;
       stream << qint32(0);

       array.append(data);
       stream.device()->seek(1);
       stream<<qint32(array.size() - 1);
#ifdef QT_DEBUG
       qDebug() << "size :" << array.size();
       qint64 temp = source->write(array);
       qDebug() << "size  write:" << temp << " size packege:" << array.size();
       return temp == (array.size());
#else
       return source->write(array) == (array.size());
#endif
   }
    return false;
}

void ETcpSocket::calibration(){
    if(!fSynced){
        QByteArray cArray;
        QDataStream stream(&cArray,QIODevice::ReadWrite);
        stream << (CALIBRATION_SENDER | IS_DRIVER);
        stream << milliseconds(ChronoTime::now());
        lastTime = ChronoTime::now();

        source->write(cArray);
    }

}

ETcpSocket::~ETcpSocket()
{
    for(QByteArray*i:ReadyStack){
        i->clear();
        delete i;
    }
    disconnect(source,SIGNAL(connected()),this,SLOT(connected_()));
    disconnect(source,SIGNAL(disconnected()),this,SLOT(disconnected_()));
    disconnect(source,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(error_(QAbstractSocket::SocketError)));
    disconnect(source,SIGNAL(hostFound()),this,SLOT(hostFound_()));
    disconnect(source,SIGNAL(proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *)),this,SLOT(proxyAuthenticationRequired_(const QNetworkProxy &, QAuthenticator *)));
    disconnect(source,SIGNAL(stateChanged(QAbstractSocket::SocketState)),this,SLOT(stateChanged_(QAbstractSocket::SocketState)));
    disconnect(source,SIGNAL(readyRead()),this,SLOT(readReady_()));
    source->deleteLater();
}