qtforum.de

Code: Alles auswählen

QSocketEngine::QSocketEngine(QObject *parent) :
    QThread(parent)
{
    ...
    ...
    // neuen Tcp-Socket erstellen
    m_pTcpSocket = new QTcpSocket();

    //--- Objekt in diesen Thread 'verschieben'
    m_pTcpSocket->moveToThread(this);

    connect(m_pTcpSocket,   SIGNAL(readyRead()),
            this,           SLOT(ReadFromSocket() ) );
    ...
    ...
}



void QSocketEngine::run()
{
    do
    {
        // Falls in Verwendung, Socket zurücksetzen
        m_pTcpSocket->abort();

        // Mit dem Server verbinden
        m_pTcpSocket->connectToHost("192.168.1.50", 4000);
    }
    while(!m_pTcpSocket->waitForConnected());

    exec();
}

Code: Alles auswählen

Client::Client(QWidget *parent) : QDialog(parent)
{
	qDebug() << "------------- MainThread Ctr. Beginn" <<  GetCurrentThreadId();

    ....
    ....
    //--- SocketEngine erstellen
    pSocketEngine = new QSocketEngine(this);

    pSocketEngine->start();

	qDebug() << "------------- MainThread Ctr. End" <<  GetCurrentThreadId();
}


void Client::ProcessData()
{
	qDebug() << "------------- MainThread ProcessData Beginn" <<  GetCurrentThreadId();
    Sleep(500);
	qDebug() << "------------- MainThread ProcessData End" <<  GetCurrentThreadId();
}

Code: Alles auswählen

#include "qSocketEngine.h"
#include "windows.h"

#include "client.h"

#define CONNECTDEUG

QSocketEngine::QSocketEngine(QObject *parent) :
    QThread(parent)
{
    qDebug() << "------------- SocketEngine ctr. Beginn" <<  GetCurrentThreadId();

    // neuen Tcp-Socket erstellen
    m_pTcpSocket = new QTcpSocket();

    //--- Objekt in diesen Thread 'verschieben'
    m_pTcpSocket->moveToThread(this);

    connect(this, SIGNAL(DataReady()),
            (Client *)parent, SLOT(ProcessData()) );

    connect(m_pTcpSocket,   SIGNAL(readyRead()),
            this,           SLOT(ReadFromSocket() ) );
    connect(m_pTcpSocket,   SIGNAL(error( QAbstractSocket::SocketError)),
            this,           SLOT(displayError(QAbstractSocket::SocketError) ), Qt::DirectConnection);
    connect(m_pTcpSocket,   SIGNAL(stateChanged(QAbstractSocket::SocketState)),
            this,           SLOT(SocketStateChanged(QAbstractSocket::SocketState)), Qt::DirectConnection);

    qDebug() << "------------- SocketEngine ctr. End" <<  GetCurrentThreadId();
}


void QSocketEngine::ReadFromSocket()
{
    qDebug() << "------------- SocketEngine ReadFromSocket Begin" <<  GetCurrentThreadId();
    while(m_pTcpSocket->bytesAvailable())
    {
        ....
        ....        
        emit(DataReady());
    }

    qDebug() << "------------- SocketEngine ReadFromSocket End" <<  GetCurrentThreadId();
}


void QSocketEngine::run()
{
    static int nConnect = 0;

    while(true)
    {
        do
        {
            qDebug() << "------------- SocketEngine run" <<  GetCurrentThreadId();
            nConnect++;
            blockSize = 0;

            // Falls in Verwendung, Socket zurücksetzen
            m_pTcpSocket->abort();

            // Mit dem Server verbinden
            m_pTcpSocket->connectToHost("192.168.1.50", 4000);

        }
        while(!m_pTcpSocket->waitForConnected());

        exec();

    }
}



void QSocketEngine::SocketStateChanged(QAbstractSocket::SocketState socketState)
{
    qDebug() << "------------- SocketEngine SocketStateChanged" <<  GetCurrentThreadId();

    if(socketState == QAbstractSocket::ClosingState)
    {
        exit(0);
    }

}

Code: Alles auswählen

QSocketEngine::QSocketEngine(QObject *parent) :
    QThread(parent)
{
    qDebug() << "------------- SocketEngine ctr. Beginn" <<  GetCurrentThreadId();

    // neuen Tcp-Socket erstellen
    m_pTcpSocket = new QTcpSocket();

    //--- Objekt in diesen Thread 'verschieben'
    m_pTcpSocket->moveToThread(this);

    connect(this, SIGNAL(DataReady()),
            (Client *)parent, SLOT(ProcessData()) );

    connect(m_pTcpSocket,   SIGNAL(readyRead()),
            this,           SLOT(ReadFromSocket() ) );
    connect(m_pTcpSocket,   SIGNAL(error( QAbstractSocket::SocketError)),
            this,           SLOT(displayError(QAbstractSocket::SocketError) ), Qt::DirectConnection);
    connect(m_pTcpSocket,   SIGNAL(stateChanged(QAbstractSocket::SocketState)),
            this,           SLOT(SocketStateChanged(QAbstractSocket::SocketState)), Qt::DirectConnection);

    qDebug() << "------------- SocketEngine ctr. End" <<  GetCurrentThreadId();
} 

Code: Alles auswählen

void QSocketEngine::run()
{
    static int nConnect = 0;

    while(true)
    {
        do
        {
            qDebug() << "------------- SocketEngine run" <<  GetCurrentThreadId();
            nConnect++;
            blockSize = 0;

            // Falls in Verwendung, Socket zurücksetzen
            m_pTcpSocket->abort();

            // Mit dem Server verbinden
            m_pTcpSocket->connectToHost("192.168.1.50", 4000);

        }
        while(!m_pTcpSocket->waitForConnected());

        exec();

    }
} 

Code: Alles auswählen

void QSocketEngine::run()
{
    static int nConnect = 0;

    // neuen Tcp-Socket erstellen
    m_pTcpSocket = new QTcpSocket();

    connect(m_pTcpSocket,   SIGNAL(readyRead()),
            this,           SLOT(ReadFromSocket() ) );
    connect(m_pTcpSocket,   SIGNAL(error( QAbstractSocket::SocketError)),
            this,           SLOT(displayError(QAbstractSocket::SocketError) ), Qt::DirectConnection);
    connect(m_pTcpSocket,   SIGNAL(stateChanged(QAbstractSocket::SocketState)),
            this,           SLOT(SocketStateChanged(QAbstractSocket::SocketState)), Qt::DirectConnection);

    //--- Objekt in diesen Thread 'verschieben'
   /* m_pTcpSocket->moveToThread(this); */ // scheint keinen Effekt zu haben

 while(true)
    {
        do
        {
            qDebug() << "------------- SocketEngine run" <<  GetCurrentThreadId();
            nConnect++;
            blockSize = 0;

            // Falls in Verwendung, Socket zurücksetzen
            m_pTcpSocket->abort();

            // Mit dem Server verbinden
            m_pTcpSocket->connectToHost("192.168.1.50", 4000);

        }
        while(!m_pTcpSocket->waitForConnected());

        exec();

    }
}

Code: Alles auswählen

Client::Client(QWidget *parent) : QDialog(parent)
{
    qDebug() << "------------- MainThread Ctr. Beginn" << QObject::thread();
	...
	...

    //--- SocketEngine (ohne Parent!!!) erstellen
    pSocketEngine = new QSocketEngine();

    connect(pSocketEngine, SIGNAL(DataReady()),
            this, SLOT(ProcessData()), Qt::QueuedConnection);

    pSocketEngine->start();

	qDebug() << "------------- MainThread Ctr. End" <<  QObject::thread() << endl;;
}



QSocketEngine::QSocketEngine(QObject *parent) :
    QThread(parent)
{
    qDebug() << "------------- SocketEngine ctr. Beginn" <<  QObject::thread();

    moveToThread(this);	

	// neuen Tcp-Socket erstellen
    m_pTcpSocket = new QTcpSocket();

    //--- Objekt in diesen Thread 'verschieben'
	m_pTcpSocket->moveToThread(this);

    connect(m_pTcpSocket,   SIGNAL(readyRead()),
            this,           SLOT(ReadFromSocket() ) );
    connect(m_pTcpSocket,   SIGNAL(error( QAbstractSocket::SocketError)),
            this,           SLOT(displayError(QAbstractSocket::SocketError) ), Qt::DirectConnection);
    connect(m_pTcpSocket,   SIGNAL(stateChanged(QAbstractSocket::SocketState)),
            this,           SLOT(SocketStateChanged(QAbstractSocket::SocketState)), Qt::DirectConnection);

	qDebug() << "------------- SocketEngine ctr. End" <<  QObject::thread() << endl;
}


void QSocketEngine::ReadFromSocket()
{
	qDebug() << "------------- SocketEngine ReadFromSocket Begin" <<  QThread::thread();
    while(m_pTcpSocket->bytesAvailable())
    {
		...
		...
        emit(DataReady());

        qDebug() << "bytesAvailable after read:" << m_pTcpSocket->bytesAvailable() << endl;
    }

    qDebug() << "------------- SocketEngine ReadFromSocket End" <<  QThread::thread();
}

Code: Alles auswählen

void QSocketEngine::run()
{
    QTCPSocket mySock;
 
    /// endlosSchleife für connectionversuche 
    while(!checkAbort())  /// checkAbort ist eine Funktion zum testen einer Abbruchbedingung von aussen
    {
         /// Versuchen zu verbinden 
         mySock.connect("192.168.1.50", 4000);
         /// warten ob connected ! mit einstellbaren intervall
         /// sehr ressourcenschonend, wenn hohe werte gewaehlt ... 
         if(mySock.waitForConnected(1000))  /// mal jede sekunde versuchen
         {
               /// wir wurden verbunden .... 
               /// nun einfach die daten auslesen 
               const char BufferSize = 512; /// Mal 512 byte als buffer nehmen
               QByteArray buffer(512,0);
               /// und Blockierend lesend auf den Socket Schicken 
               /// in ner Schleife 
               do
               {
                    qint64 bytesRead = mySock.read(buffer.data(),buffer.size());
                    if(bytesRead > 0) 
                    {
                        /// wir haben irgendwas gelesen, dass gleich an die Verarbeitungsfunktion weitergen 
                        /// im gleichen thread wenns geht ... 
                        /// performData(buffer.data(),bytesRead );
                    }
               } while (!checkAbort() && /// hier eigene Abbruchbedingungen checken etc. und vielleicht auch den SocketStatus)
              /// wir waren Connected und disconecten und nun, weil wir normal(oder unnormal) rausgeflogen sind ... 
             mySock.disconnectFromHost();
             /// Gnadenfrist geben 
             waitForDisconnected (30000);
         }
 
    }
 
} 

Code: Alles auswählen

bool QSocketEngine::checkAbort()
{
    QMutexLocker(&mcsAbort); 
    return mbAbort;
}

void QSocketEngine::setAbort(bool bAbort = true)
{
    QMutexLocker(&mcsAbort); 
    mbAbort = bAbort;
}

Code: Alles auswählen

void QSocketEngine::ShutdownConnectionThread
{
     setAbort(true); 
     /// nun sollte parallel der Thread sich runnerfahren ... 
     /// ihm die Gnadenfrist geben und warten 
     if(!wait(10000)) /// geben wir ihm mal 10 sec 
     {
          /// in wenn er es in der zeit nicht geschafft hat ...
          /// den thread ganz boese beenden ! 
          terminate ();
          /// wir hatten ja keine andere Wahl. 
          /// am besten noch die Appp benachrichtigen, dass der thread ned sauber beendete und paar dinge im undefinierten zustand sind ... 
          /// am besten ne Exception werfen oder so ! 
          throw(EThreadTerminated() )
     }
}