Russian Qt Forum

http://yandex.ru/yandsearch?text=параметр 1

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
#include <QMutex>

#include <QtNetwork/QNetworkAccessManager>
#include <QtNetwork/QNetworkReply>
#include <QtNetwork/QNetworkRequest>

//--------------------------------------------------------------------------------------
// Name: cUUploadThread
// Desc:
//--------------------------------------------------------------------------------------
class cUUploadThread : public QThread
{
    Q_OBJECT

public:
    // Constructor
    //----------------------------------------------------------------------------------
    cUUploadThread(QObject *parent);
    ~cUUploadThread();

    // Control
    //----------------------------------------------------------------------------------
    void processTask(/* your data */);

private:
    // Internal data
    //----------------------------------------------------------------------------------
    bool m_abort;

    QMutex mutex;
    QNetworkAccessManager *pManager;

    // External data
    //----------------------------------------------------------------------------------
    volatile int i;
signals:
    // Send data
    //----------------------------------------------------------------------------------
    void sendPermit();

public slots:
    // Internal control
    //----------------------------------------------------------------------------------
    void sendPart();

    // Control thread
    //----------------------------------------------------------------------------------
    void playTask();
    void stopProcess();

    // Upload control
    //----------------------------------------------------------------------------------
    void slotReadyRead();
    void slotError(QNetworkReply::NetworkError);
    void slotFinished();
    void slotUploadProgress( qint64 bytesSent, qint64 bytesTotal);

    //==================================================================================

protected:
    // Start it
    //----------------------------------------------------------------------------------
    void run();

};

#endif // MYTHREAD_H

#include "MyThread.h"

#include <QDebug>

//--------------------------------------------------------------------------------------
// cUUploadThread class constructor
//--------------------------------------------------------------------------------------
cUUploadThread::cUUploadThread(QObject *parent) :
    QThread(parent)
{
    // Nullifing data
    m_abort = false;

    pManager = 0;
}

// cUUploadThread class destructor
//--------------------------------------------------------------------------------------
cUUploadThread::~cUUploadThread()
{
    qDebug() << "cUUploadThread::~cUUploadThread()";

    mutex.lock();
    m_abort = true;
    mutex.unlock();

    wait();
}

//=============================================================================
// MAIN
//=============================================================================

// Processing the dot
//--------------------------------------------------------------------------------------
void cUUploadThread::processTask(/* your data */)
{
    qDebug() << "cUUploadThread::processTask()";

    mutex.lock();
    m_abort = false;
    mutex.unlock();

    /*
        ADD YOUR DATA FOR TASK
    */
}

// Run thread
//--------------------------------------------------------------------------------------
void cUUploadThread::run()
{
    qDebug() << "cUUploadThread::run()";

    mutex.lock();
    m_abort = false;
    mutex.unlock();

    /// IT IS THE MAIN IDEA OF MULTITHREADED APP WITH QNETWORK
    // first part sending
    connect(this, SIGNAL(sendPermit()), SLOT(sendPart()));
    emit(sendPermit());

    // enter main loop
    exec();

    qDebug() << "cUUploadThread::run() end";
}

//--------------------------------------------------------------------------------------
void cUUploadThread::sendPart()
{

    if( !pManager )
        pManager = new QNetworkAccessManager();

    QNetworkRequest request;
    request.setUrl(QUrl("http://yandex.ru/"));
    /*
        MAKE TRUE REQUEST
    */

    QNetworkReply *reply = pManager->get(request);

    connect(reply, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
            this, SLOT(slotError(QNetworkReply::NetworkError)));
    connect(reply, SIGNAL(uploadProgress(qint64,qint64)),
            this, SLOT(slotUploadProgress(qint64,qint64)));
    connect(reply, SIGNAL(finished()), this, SLOT(slotFinished()));

    qDebug() << "cUUploadThread::sendPart() OK";
}

//=============================================================================
// PUBLIC SLOTS
//=============================================================================

//--------------------------------------------------------------------------------------
void cUUploadThread::playTask()
{
    qDebug() << "cUUploadThread::playTask()";

    mutex.lock();
    m_abort = true;
    mutex.unlock();

    start();
}

// Stop thread if needable
//--------------------------------------------------------------------------------------
void cUUploadThread::stopProcess()
{
    qDebug() << "cUUploadThread::stopProcess()";

    mutex.lock();
    m_abort = true;
    mutex.unlock();

    exit(0);
    wait();

    qDebug() << "PROCESS STOPPED";
}

//--------------------------------------------------------------------------------------
void cUUploadThread::slotReadyRead()
{
    qDebug() << "cUUploadThread::slotReadyRead()";
}

//--------------------------------------------------------------------------------------
void cUUploadThread::slotError(QNetworkReply::NetworkError error)
{
    qDebug() << "cUUploadThread::slotError("
            << error << ")";

    stopProcess();
}

//--------------------------------------------------------------------------------------
void cUUploadThread::slotFinished()
{
    qDebug() << "cUUploadThread::slotFinished()";

    QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
    reply->deleteLater();

    if( reply->bytesAvailable() > 0 ) {
        QString reply_str(reply->readAll());
        qDebug() << reply_str;
    }
    else {
        qDebug() << "NO DATA TO READ";
        stopProcess();
    }

    qDebug() << "DATA OK";
}

//--------------------------------------------------------------------------------------
void cUUploadThread::slotUploadProgress( qint64 bytesSent, qint64 bytesTotal)
{
    qDebug() << bytesSent << bytesTotal;
}

cUUploadThread *tr=new cUUploadThread(0);
        tr->playTask();