QTcpSocket: no readyRead() signal even in Qthread event loop

[R-Type]

The main thread also has (or at least can have) an event loop

In application (plugin) where it doesn't work, call to ClientSocked takes place not from the main thread. And in example above, where I use ClientSocket from main(), it works.

Sure, but you are calling the socket's functions directly from the main thread which is forbidden.

You are right, connect and write had to be called also in run in this example.

[wysota]

No, connect() can be called anywhere. The point is not to call any of the methods of objects belonging to thread B from thread A. Regardless of whether there are slots involved anywhere.

So this is forbidden:

ClientSocket* c=new ClientSocket();
c->start();
Sleep(10000); // doesn't make sense
bool bConnected = c->connectToHost("localhost", 1000); // forbidden

ClientSocket* c=new ClientSocket();
c->start();
Sleep(10000); // doesn't make sense
bool bConnected = c->connectToHost("localhost", 1000); // forbidden

To copy to clipboard, switch view to plain text mode 

and if you change those calls to proper ones (using signals and slots), you'll notice there is no advantage of having a thread anywhere, it only causes trouble. Qt works in asynchronous fashion, when you try to force it to be synchronous (like in your code above), you'll have more problems with it than benefits from not having to switch your thinking into asynchronous mode.

[R-Type]

Beow is "true" asynchronous version where communication takes place only via signals and slots (no threads!):

class ClientSocket : public QObject
{
  Q_OBJECT
public:  
  ClientSocket() : QObject() , m_socket(new QTcpSocket(this)) {
      connect(m_socket, SIGNAL(readyRead()), this, SLOT(test()));
    }
  virtual ~ClientSocket() {};
  bool connectToHost(QString host, int port) {
    m_socket->connectToHost(host, port);
    return m_socket->waitForConnected(1000);
  }
  void write(const char* Data,unsigned int nBytes) {
    if (m_socket && (m_socket->state() == QAbstractSocket::ConnectedState))
    {
      m_socket->write(Data);
      m_socket->flush();    
    }
  }
 
public slots:
  void writeData(const char* Data,unsigned int nBytes) { write(Data, nBytes); }
  void connectSlot(const QString& host, int port) { connectToHost(host, port); }
  void test() { throw new std::runtime_error("ok"); }
private:
  QTcpSocket* m_socket;
};

class ClientSocket : public QObject
{
  Q_OBJECT
public:  
  ClientSocket() : QObject() , m_socket(new QTcpSocket(this)) {
      connect(m_socket, SIGNAL(readyRead()), this, SLOT(test()));
    }
  virtual ~ClientSocket() {};
  bool connectToHost(QString host, int port) {
    m_socket->connectToHost(host, port);
    return m_socket->waitForConnected(1000);
  }
  void write(const char* Data,unsigned int nBytes) {
    if (m_socket && (m_socket->state() == QAbstractSocket::ConnectedState))
    {
      m_socket->write(Data);
      m_socket->flush();    
    }
  }
  
public slots:
  void writeData(const char* Data,unsigned int nBytes) { write(Data, nBytes); }
  void connectSlot(const QString& host, int port) { connectToHost(host, port); }
  void test() { throw new std::runtime_error("ok"); }
private:
  QTcpSocket* m_socket;
};

To copy to clipboard, switch view to plain text mode 

Here is the calling part:

connect(this, SIGNAL(connectSignal(const QString&, int)), &m_ClientSocket, SLOT(connectSlot(const QString&, int)));
    connect(this, SIGNAL(writeData(const char*,unsigned int)), &m_ClientSocket, SLOT(writeData(const char*,unsigned int)));
    emit(connectSignal("localhost", 1000));
    emit(writeData("rtst", 4));

connect(this, SIGNAL(connectSignal(const QString&, int)), &m_ClientSocket, SLOT(connectSlot(const QString&, int)));
    connect(this, SIGNAL(writeData(const char*,unsigned int)), &m_ClientSocket, SLOT(writeData(const char*,unsigned int)));
    emit(connectSignal("localhost", 1000));
    emit(writeData("rtst", 4));

To copy to clipboard, switch view to plain text mode 

test() signal still not called. What is wrong?

connectSlot() and writeData() slots get called.

---

Added after 4 minutes:

if I use Qt::QueuedConnection for 2 last connect()s then neither connectSlot() nor writeData() are called.

[wysota]

I see some synchronous things in your code. Besides, if you want to post an example, make it a complete one, including main().

[R-Type]

I see some synchronous things in your code.

Do you mean connect/write signals sequence? It's just to make example smaller. Normally write should be called in slot for connected() signal, but in example it doesn't matter because local connections are quite fast.

Besides, if you want to post an example

As I mentioned, the problem is that in example it works and in real project the same code doesn't call test() slot. Here is the complete example:
test.h

#include <ClientSocket.h>
 
class Test : public QObject
{
  Q_OBJECT
 
signals:
    void connectSignal(const QString& host, int port);
    void writeData(const char* data,unsigned int length);
 
public:
    Test();
private:
    ClientSocket m_ClientSocket;
};

#include <ClientSocket.h>

class Test : public QObject
{
  Q_OBJECT

signals:
    void connectSignal(const QString& host, int port);
    void writeData(const char* data,unsigned int length);

public:
    Test();
private:
    ClientSocket m_ClientSocket;
};

To copy to clipboard, switch view to plain text mode 

test.cpp

#include "test.h"
 
Test::Test() : QObject(), m_ClientSocket() {
   connect(this, SIGNAL(connectSignal(const QString&, int)), &m_ClientSocket, SLOT(connectSlot(const QString&, int)));
   connect(this, SIGNAL(writeData(const char*,unsigned int)), &m_ClientSocket, SLOT(writeData(const char*,unsigned int)));
   emit(connectSignal("localhost", 1000));
   emit(writeData("rtst", 4));
}

#include "test.h"

Test::Test() : QObject(), m_ClientSocket() {
   connect(this, SIGNAL(connectSignal(const QString&, int)), &m_ClientSocket, SLOT(connectSlot(const QString&, int)));
   connect(this, SIGNAL(writeData(const char*,unsigned int)), &m_ClientSocket, SLOT(writeData(const char*,unsigned int)));
   emit(connectSignal("localhost", 1000));
   emit(writeData("rtst", 4));
}

To copy to clipboard, switch view to plain text mode 

ClientSocket.h

#include <QTcpSocket>
 
class ClientSocket : public QObject
{
  Q_OBJECT
 
public:
  ClientSocket() : QObject()
    , m_socket(new QTcpSocket(this)) {
      connect(m_socket, SIGNAL(readyRead()), this, SLOT(test()));
    }
  bool connectToHost(QString host, int port) {
    m_socket->connectToHost(host, port);
    return m_socket->waitForConnected(1000);
  }
  void write(const char* Data,unsigned int nBytes) {
    if (m_socket && (m_socket->state() == QAbstractSocket::ConnectedState))
    {
      m_socket->write(Data);
      m_socket->flush();
    }
  }
 
public slots:
  void writeData(const char* Data,unsigned int nBytes) { write(Data, nBytes); }
  void connectSlot(const QString& host, int port) { connectToHost(host, port); }
  void test() { qDebug()<<"ok"; }
 
private:
  QTcpSocket* m_socket;
};

#include <QTcpSocket>

class ClientSocket : public QObject
{
  Q_OBJECT

public:
  ClientSocket() : QObject()
    , m_socket(new QTcpSocket(this)) {
      connect(m_socket, SIGNAL(readyRead()), this, SLOT(test()));
    }
  bool connectToHost(QString host, int port) {
    m_socket->connectToHost(host, port);
    return m_socket->waitForConnected(1000);
  }
  void write(const char* Data,unsigned int nBytes) {
    if (m_socket && (m_socket->state() == QAbstractSocket::ConnectedState))
    {
      m_socket->write(Data);
      m_socket->flush();
    }
  }

public slots:
  void writeData(const char* Data,unsigned int nBytes) { write(Data, nBytes); }
  void connectSlot(const QString& host, int port) { connectToHost(host, port); }
  void test() { qDebug()<<"ok"; }

private:
  QTcpSocket* m_socket;
};

To copy to clipboard, switch view to plain text mode 

main.cpp

#include <QtCore/QCoreApplication>
#include "test.h"
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Test t;
    return a.exec();
}

#include <QtCore/QCoreApplication>
#include "test.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Test t;
    return a.exec();
}

To copy to clipboard, switch view to plain text mode 

[wysota]

Do you mean connect/write signals sequence?

I mean waitFor*() calls and using sleep().

As I mentioned, the problem is that in example it works and in real project the same code doesn't call test() slot.

There is no point in fixing code that works Your "real project" apparently does something which breaks the code. It may block the event loop or don't start one at all.