Slt, j'ai fait une classe CTache, qui dérive de QThread. De celle-ci, j'en dérive une autre. Uploader. Je crée la socket dans son run() et je connecte ses signaux à des slots de Uploader. Mais en fait cette socket est totalement bidon. Elle ne marche pas, bug qt ? J'ai avant celà un thread principal qui se connecte au serveur (sur le même port). Tout se passe bien. Quand je rentre dans le run() du Uploader, il se connecte bien (le serveur reçoit bien une connection, c'est sûr) mais la socket n'emet aucuns signaux... Après, j'ai essayé d'écrire dans la socket mais elle n'envoie strictement rien... Pourquoi ?

Voici le code de ces deux classes. Si quelqu'un arrive à me sortir de ce pétrain, je le remercie, c'est pour un projet à rendre dans une semaine !

Merci d'avance !!!!

CTaches.h
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
 
#ifndef CTACHES_H
#define CTACHES_H
 
 
#include <QThread>
#include <QString>
#include <QtNetwork>
#include <QTcpSocket>
 
#include "CConnRapide.h"
#include "CstTransactions.h"
 
namespace Projet
{
	class CTache : public QThread
	{
		Q_OBJECT
	  protected:
		QTcpSocket* m_Socket;
		bool m_Connecte;
 
		quint64 m_IdProvisoire;
		bool m_Erreur;
		bool m_FinTransfert;
 
	  public slots:
		// Socket
		void ConnectionEtablie();
		void DonneesRecues();
		void Deconnecte();
		void ErreurSocket(QAbstractSocket::SocketError erreur);
 
	  signals:
		void AvancementFic(quint64 Id, quint64 Avancement);
		void EnvoiFini(quint64 Id);
		void ErreurTransfert(quint32 IdErr);
 
		// Debug
		void Debug(QString Str);
 
	  public:
		CTache(quint64 IdProvisoire, QObject* Parent);
 
		virtual void run() = 0;
	};// class CTache
 
 
 
	class CUploader : public CTache
	{
		Q_OBJECT
	  protected:
		QString m_Path;
 
	  public:
		CUploader(quint64 IdProvisoire, QString Path, QObject* Parent);
 
		virtual void run();
	};
}// namespace Projet
 
 
#endif

CTaches.cpp

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
 
#include "CTaches.h"
 
#define PCT Projet::CTache
 
using namespace nsCst;
 
PCT::CTache(quint64 IdProvisoire, QObject* Parent) 
	: QThread(Parent)
{
 
	m_IdProvisoire = IdProvisoire;
}
 
 
 
void PCT::ConnectionEtablie()
{
	emit Debug("Tache : Connexion etablie");
	m_Connecte = true;
}// ConnectionEtablie()
 
 
 
void PCT::DonneesRecues()
{
	QTcpSocket* m_Socket = (QTcpSocket*) sender();
	quint32 Rep;
	QDataStream in(m_Socket);
	in >> Rep;
 
	if(Rep == CstBienRecu)
	{
		m_FinTransfert = true;
		emit EnvoiFini(m_IdProvisoire);
	}
	else
	{
		m_Erreur = true;
		emit ErreurTransfert(Rep);
	}
}// DonneesRecues()
 
 
 
void PCT::Deconnecte()
{
	m_FinTransfert = true;
}// Deconnecte()
 
 
 
void PCT::ErreurSocket(QAbstractSocket::SocketError erreur)
{
	emit Debug("Tache : Erreur socket");
 
	switch(erreur)
	{
		case QAbstractSocket::HostNotFoundError:
			break;
		case QAbstractSocket::ConnectionRefusedError:
			break;
		case QAbstractSocket::RemoteHostClosedError:
 
			break;
		default:
			break;
	}
	emit ErreurTransfert(666);
	m_Erreur = true;
}// ErreurSocket()
 
 
 
 
 
#undef PCT
 
 
 
 
 
 
#define PCU Projet::CUploader
 
 
PCU::CUploader(quint64 IdProvisoire, QString Path, QObject* Parent)
	: CTache(IdProvisoire, Parent)
{
	m_Path = Path;
}// CUploader
 
 
void PCU::run()
{
	m_Socket = new QTcpSocket();
		connect(m_Socket, SIGNAL(readyRead()), this, SLOT(DonneesRecues()));
		connect(m_Socket, SIGNAL(connected()), this, SLOT(ConnectionEtablie()));
		connect(m_Socket, SIGNAL(disconnected()), this, SLOT(Deconnecte()));
		connect(m_Socket, SIGNAL(error(QAbstractSocket::SocketError)),
			this, SLOT(ErreurSocket(QAbstractSocket::SocketError)));
	m_Connecte = false;
	m_FinTransfert = false;
	m_Erreur = false;
 
	m_Socket->connectToHost(CConnRapide::Get()->GetHote(), CConnRapide::Get()->GetPort());
 
	// On attends d'être connecté au serveur
	while(!m_Connecte)
	{
		emit Debug("Uploader : Nouveau tour");
		if(m_Erreur) return;
		sleep(2);
	}
	sleep(1);
 
	QFile Fic (m_Path);
	Fic.open(QIODevice::ReadOnly);
 
	quint64 Taille = Fic.size();
	{
		QByteArray paquet;
		QDataStream out(&paquet, QIODevice::WriteOnly);
 
		out << qToBigEndian(CstRqEnvFic)
			<< qToBigEndian(m_IdProvisoire)
			<< qToBigEndian(Taille);
		m_Socket->write(paquet);
	}
 
	quint64 Envoye = 0;
	while(!m_Erreur && Fic.bytesAvailable())
	{
		Envoye += m_Socket->write(Fic.read(50000));
		emit AvancementFic(m_IdProvisoire, Envoye);
	}
 
	// On attends que le serveur nous dise qu'il ait bien tout reçu
	while(!m_FinTransfert) if(m_Erreur) return;
 
}// run()
 
 
 
#undef PCU
Encore merci !