Discussion :

[kek's]

Bonjour,

Après quelques post portant sur la communication interProcessus, j'ai décidé d'utiliser la méthode fourni par l'exemple Qt mais je pense qu'il y a des étapes manquante lors de l'initialisation du Qlocalserver, est-e que quelqu'un pourrai me décrire les étapes d'initialisation d'un Qlocalserver ??

Je vous met mon code qui actuellement ne fonctionne pas car server->listen ne fonctionne pas :

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
BoxServer::BoxServer(void)
{
	
	server = new QLocalServer(); // déclare un nouveau server
	QString NomServeur = "local";
	server->serverName() = NomServeur; //Je lui affecte un nom
	if(server->isListening()) // je vérifie qu'il ne soit pas déjà en lecture
	{
		server->close(); // si celui ci est en lecture, j'arrête la lecture
		server->listen(NomServeur); // et je relance une lecture sur le serveur que je veux
	}
	else if(!server->listen(NomServeur)) // s'il n'est pas déjà en lecture, je vérifie qu'il "lit" bien mon serveur et si ce n'est pas le cas il sort de la méthode
         return;

	QObject::connect(server, SIGNAL(newConnection()), server, SLOT(sendData())); // lorsqu'il y a une nouvelle connection le server lui envoi les données
}

Je vous remercie d'avance pour votre aide!

[kek's]

Re bonjour,

J'ai trouvé un tuto : http://wiki.forum.nokia.com/index.ph...6_QLocalServer

Qui nous explique mieux le fonctionnement du côté client et du côté serveur.

Or il me reste encore un petit problème lorsque j'appelle mon constructeur surchargé dans le main pour lancer le serveur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

BoxServer::BoxServer("local", this);

l'erreur produite est la suivante:

error C2673: 'main'*: les fonctions globales n'ont pas de pointeurs 'this'


Ce qui est normal mais je sais pas quel objet je doit passer en paramètre !

Si quelqu'un a déjà géré ce problème je l'écoute.

Je vous remercie d'avance !

[superjaja]

Tu peux montrer la totalité du code de ton main ?

[kek's]

Bonjour superjaja,

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
#include <QtCore/QCoreApplication>

#include "MessagingSystemSerial.h"
#include "SerialDevice.h"
#include "BoxServer.h"

#define SVN "$Rev: 643 $"

int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);
	
	
	BoxServer::BoxServer("local", /* OBJECT */);

	//Revision SVN
		QString rev(SVN);
		rev = rev.replace(" $","").replace("$Rev: ","");
		a.setApplicationVersion("2.5." + rev);

	// mise en route du thread
	MessagingSystemSerial::getInstance()->InitBOX();

	// recupération des messages
	MessagingSystemSerial::getInstance()->processMessages();

	

	return a.exec();
}

Voici mon main, si vous voulez plus d'infos dites le moi !

Merci de votre aide !

[superjaja]

Je comprends pas tout car toutes les methode de test classes sont statique ?

Ex :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

BoxServer::BoxServer("local", /* OBJECT */);

A mon avis fait plutot ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

BoxServer server("local");

Cela devrait mieux marcher mais je pense qu'il y a d'autre problème dans ton code comme ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

server->serverName() = NomServeur;

Voir doc Qt serverName() retourne une QString et ne sert pas a affecté un nom au server.

[kek's]

J'ai suivi ton conseil or cela me donne une autre erreur :

Unhandled exception at 0x03f92424 in BoxConnector.exe: 0xC00000FD: Stack overflow.

Et pour cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

server->serverName() = NomServeur;

la fonction servername() renvoi bien un Qstring, c'est pourquoi dans un premier temps j'avais fait cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if(!server->listen(server->servername())) 
         return;

mais rien à faire il ne lit pas et sort directement de la méthode.

je vais te remettre le constructeur que j'utilise pour déclarer mon server ainsi que mon main dans lequel j'appelle mon constructeur.

Voici le main :

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
#include <QtCore/QCoreApplication>

#include "MessagingSystemSerial.h"
#include "SerialDevice.h"
#include "BoxServer.h"

#define SVN "$Rev: 643 $"

int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);
	
	
	BoxServer server("local");

	//Revision SVN
		QString rev(SVN);
		rev = rev.replace(" $","").replace("$Rev: ","");
		a.setApplicationVersion("2.5." + rev);

	// mise en route du thread
	MessagingSystemSerial::getInstance()->InitBOX();

	// recupération des messages
	MessagingSystemSerial::getInstance()->processMessages();

	

	return a.exec();
}

Voici le constructeur :

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
 
BoxServer::BoxServer(QString servername)
{
 
	server = new QLocalServer();
	if(server->isListening())
	{
		server->close();
		server->listen(servername);
	}
	else if(!server->listen(servername))
        return;
 
      QObject::connect(server, SIGNAL(newConnection()), server,    SLOT(sendData()));
}

Merci de ton aide et encore désolé je suis débutant en Qt donc je me perds un peu !

[superjaja]

Je suis désolé mais peux-tu exprimer exactement ton besoins ? A quoi sert ton serveur ? tu veux envoyer des info à qui ? Quels types d'info ?

[kek's]

En fait, je dois établir une connexion entre 2 exécutables donc utiliser la communication interprocess (IPC). Or étant sur windows je ne peux pas utiliser Qdbus donc j'utilise la même méthode que l'exemple Qt IPC. Dans lequel on utilise Qlocalserver et Qlocalsocket pour communiquer. Dons dans mon cas, mon server (Qlocalserver) correspond à un de mes exécutables et j'utilise une Qlocalsocket à partir de l'autre exécutable pour communiquer.

As-tu compris maintenant ? Si tu n'as toujours pas compris demande moi plus de précision je suis à ton entière disposition !

Merci pour ton aide !

[superjaja]

Bon j'ai bien compris ce que tu veux faire. Apres ce que je en comprends pas c'est ce que tu n'arrives pas a faire en gros dans quelle partie tu bloques.

Le principe de QLocalServer c'est de créer un serveur avec un non et de le mettre à l'écoute d'une connexion client avec la méthode listen(). A chaque fois qu'un client accède à ton serveur tu as le signal newConnection () qui est émit. Apres tu peux récupérer la connexion avec le client grâce à la méthode nextPendingConnection (). Puis avec maintenant ton QlocalSocket (c'est un de tes client connecté a ton serveur) tu peux lire et écrire des infos.

En gros pour faire une serveur local tu dois avoir une dizaine de lignes max à écrire je pense.

A mon avis fait déjà un truc simple avec un serveur qui fonctionne bien et après utilise des threads si tu as besoins pour gérer les connexions. Car je comprends vraiment pas trop ton code...

[kek's]

Je pense avoir trouvé mon erreur superjaja !

En fait, c'est juste une erreur de compréhension de la fonction listen().

Je vais tenter de le résoudre et je tiendrai au courant !

Merci beaucoup pour ton aide.

[kek's]

Salut superjaja,

Je pensais avoir trouvé mon erreur, or j'ai toujours le même et jvoudrais savoir ce que cela signifie exactement. J'ai signalé l'endroit dans mon code !

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
bool BoxServer::InitServer(QString servername) // nom du serveur donné dans le main, est "local"
{
    m_server = new QLocalServer(this);
	m_server->setMaxPendingConnections(5);
	
	if (!m_server->listen(servername)) // le server passe toujours par ici !
	{
        qDebug() << "Not able to start the Server";
		return false;
        }
	else
	{
		QObject::connect(m_server, SIGNAL(newConnection()), this, SLOT(socket_new_connection()));
		return true;
	}
}

Est-ce que tu pourrais m'expliquer ce qui se passe?
Parce que j'ai un véritable problème de compréhension au niveau du listen !
Ensuit je me demande si la déclaration de mon serveur est bonne ? surtout en ce qui concerne le nom du serveur ?


Merci d'avance pour ton aide !

[superjaja]

Comme ça ton code me semble correct je ne vois pas pourquoi le listen() te retournerait false...
Le nom passé en argument du listen() est juste un identifiant nécessaire pour identifier le serveur. En gros les clients pour qu'il se connectes a ton serveur ils ont besoin de connaitre son nom.

Est ce qu'un client arrive a se connecter a ton serveur ou cela ne fonctionne pas ?
Essaie d'enlever le contrôle sur le listen() juste pour faire le test si un client arrive a se connecter.

Mon tout ton .h et cpp de ta classe BoxServer et aussi le main pour voir comment tu l'utilises.

[superjaja]

Tu trouveras normalement en pièce jointe les projets d'un Server et d'un Client que j'ai fait très rapidement sous QtCreator pour te montrer comment ça fonctionne.

[kek's]

J'ai fais le test et apparemment le client ne se connecte pas au serveur car le signal newconnection n'a pas été émit.

Voici le BoxServer.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
 
#include "BoxServer.h"
///////////////////////////////
#include <QtNetwork>
#include <qlocalserver.h>
#include <qlocalsocket.h>
#include <QString>
 
 
#include "MessagingSystemSerial.h"
#include "ServerThread.h"
 
BoxServer::BoxServer()
{
}
 
bool BoxServer::InitServer(QString servername)
{
    m_server = new QLocalServer(this);
	m_server->setMaxPendingConnections(5);
 
	/*if (!m_server->listen(servername)) 
	{
        qDebug() << "Not able to start the Server";
		return false;
    }
	else
	{*/
		QObject::connect(m_server, SIGNAL(newConnection()), this, SLOT(socket_new_connection()));
		return true;
	/*}*/
}
 
void BoxServer::InitConnect()
{
	if(BoxServer::getInstance()->isRunning())
		BoxServer::getInstance()->terminate();
 
	ServerThread::getInstance()->start();
}
 
 
void BoxServer::socket_new_connection() 
{
 
    QLocalSocket *clientConnection = m_server->nextPendingConnection();
 
    while (clientConnection->bytesAvailable() < (int)sizeof(quint32))
        clientConnection->waitForReadyRead();
 
 
    QObject::connect(clientConnection, SIGNAL(disconnected()), clientConnection, SLOT(deleteLater()));
 
    QDataStream in(clientConnection);
    in.setVersion(QDataStream::Qt_4_0);
    if (clientConnection->bytesAvailable() < (int)sizeof(quint16)) {
        return;
    }
    QString message;
    in >> message;
 
    emit messageReceived(message);
}
 
BoxServer::~BoxServer() 
{
}

Voici le BoxServer.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
 
#ifndef BOXSERVER_H
 #define BOXSERVER_H
 
#include <QThread>
#include <QStringList>
#include <QLocalServer>
 
#include "singleton.h"
 
class QLocalServer;
 
class BoxServer : public QThread, public Singleton <BoxServer>
 {
	 Q_OBJECT
 
		friend class Singleton<BoxServer>;
 
public:
	BoxServer();
    bool InitServer(QString servername);
    ~BoxServer();
 
public slots:
    void socket_new_connection();
	void InitConnect();
 
signals:
    void messageReceived(QString);
 
 
private:
    QLocalServer* m_server;
 
};
 
 #endif

Et voici le main.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
 
#include <QtCore/QCoreApplication>
 
#include "MessagingSystemSerial.h"
#include "SerialDevice.h"
#include "BoxServer.h"
 
#define SVN "$Rev: 643 $"
 
int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);
 
	//Mise en route du Thread de connection 
	BoxServer::getInstance()->InitConnect();
 
	//Initialisation du serveur
	BoxServer::getInstance()->InitServer("local");
 
	//Revision SVN
		QString rev(SVN);
		rev = rev.replace(" $","").replace("$Rev: ","");
		a.setApplicationVersion("2.5." + rev);
 
	// mise en route du thread pour la récupération de données
	MessagingSystemSerial::getInstance()->InitBOX();
 
	// recupération des messages
	MessagingSystemSerial::getInstance()->processMessages();
 
 
 
	return a.exec();
}

Merci pour ton exemple mais je n'ai pas trop pu m'en servir car moi c'est un projet Qt console Donc j'utilise pas QtGui. Mais je vois pas pourquoi cela ne marche pas car j'ai pu lire différents tuto dont l'exemple Qt sur L'IPC et la méthode est la même sauf que eux aussi utilisent QtGUI.

Donc j'ai une question est-ce que je peux utiliser ce code pour un projet Qt console vu que tous les sujets que j'ai pu voir travaillés avec la librairie QtGUI ?

Merci de ta patiente et de ton aide cela m'aide beaucoup même si cela ne se voit pas encore !!

[superjaja]

J'ai du mal a comprendre ton code. Tu veux pas deja le faire fonctionner sans ta classe singleton. En plus pourquoi utiliser un singleton ??

C'est quoi serveurThread ???

Par exemple tu herites d'un QThread et tu n'implemente pas la methode run()... Ta methode InitConnect() ne sert a rien car tu n'as pas crée de thread.

Je pense que tu as beaucoups de confusion et que tu veux faire un truc compliqué tout de suite. De meme je ne vois plus le listen() dans ton code. A mon avis fait un serveur simple sans singleton qui fonctione et un client qui fonctionne. Par la suite on verra.

[kek's]

Salut superjaja,

J'ai changé quelques trucs du côté serveur. J'ai enlevé le thread qui ne sert a rien et le problème venait du fait que le nom du serveur était déjà utilisé tout simplement donc maintenant celui-ci tourne mais j'aimerai pouvoir supprimer mon serveur à la fin de mon application ! pour cela j'ai essayer de faire une méthode DeleteServer() car mon destructeur ne le supprime pas.

Je te montre le code de celle-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void BoxServer::DeleteServer()
{
	QLocalServer* ServerDel = GetServer();
	ServerDel->close();
	delete ServerDel;
}

// accesseur pour m_server
QLocalServer* BoxServer::GetServer()
{
	return m_server;
}

Merci de ton aide et en ce qui concerne la difficulté du projet, je suis obligé de travaillé là-dessus car c'est un projet d'entreprise qui m'a été confié.

Merci encore !

[superjaja]

En regardant juste ces 3 lignes de code je ne peux pas dire grand chose. Tout me semble juste a premiere vue.

En revanche je te post un appli console serveur qui fonctionne (enfin j'ai pas fait beacoup de tests...) et qui plante pas quand tu fermes l'appli.

fichier localserver.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
#ifndef LOCALSERVER_H
#define LOCALSERVER_H
 
#include <QObject>
 
#include <QLocalServer>
#include <QLocalSocket>
 
class LocalServer : public QObject
{
Q_OBJECT
public:
    explicit LocalServer(QObject *parent = 0);
 
    LocalServer(QString serverName);
 
 
private:
    QLocalServer m_server;
 
 
signals:
 
public slots:
 
private slots:
   void NewConnectionOnServer();
   void ReadOK();
 
 
 
};
 
#endif // LOCALSERVER_H

fichier localserver.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
 
#include "localserver.h"
 
#include <QtCore/QCoreApplication>
#include <QTimer>
 
 
LocalServer::LocalServer(QObject *parent) :
    QObject(parent) , m_server(this)
{
}
 
 
LocalServer::LocalServer(QString serverName) : m_server(this)
{
    connect(&this->m_server,SIGNAL(newConnection()),this,SLOT(NewConnectionOnServer()));
 
    QTextStream out(stdout);
 
    if( !this->m_server.listen(serverName))
    {
       out << "Problème le server [" << serverName << "] est déjà à l'écoute..." << endl ;
       QTimer::singleShot(2000, QCoreApplication::instance(), SLOT(quit()));
    }
    else
    {
       out << "Installation du serveur [" << serverName << "]" << endl;
    }
}
 
 
void LocalServer::NewConnectionOnServer()
{
    if(this->m_server.hasPendingConnections() == true)
    {
       QLocalSocket* client =  this->m_server.nextPendingConnection();
       connect(client,SIGNAL(readyRead()),this,SLOT(ReadOK()));
 
       QTextStream out(stdout);
       out << "Nouvelle connexion sur le serveur " << endl;
    }
}
 
void LocalServer::ReadOK()
{
    QLocalSocket* client = qobject_cast<QLocalSocket*>(sender());
 
    QString str = client->readAll();
 
    QTextStream out(stdout);
 
    out << QString("##: " + str +"\n") << endl;
 
}

fichier main.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <QtCore/QCoreApplication>
 
#include "localserver.h"
 
#define SERVER_NAME "local"
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    LocalServer server(SERVER_NAME);
 
    return a.exec();
}

Apres il me faut plus d'info mais a mon avis tu dois avoir des problèmes sur la gestion du pointeur QLocalServer. Tu devrais faire comme moi c'est a dire ne pas utiliser un pointeur comme ça tu n'auras pas de problème de gestion de mémoire...

Sinon tu m'as dit pourquoi tu utilises un singleton ??? Est ce vraiment necessaire ??

[kek's]

Salut superjaja,

Désolé de te répondre que maintenant mais je n'étais pas disponible ces derniers jours !

J'ai vu ton code, il est super mais j'ai le même problème lorsque j'arrête le debug
et que je relance juste après il me dit que le serveur est déjà à l'écoute ce qui est normal, j'aimerai savoir comment faire pour le supprimer et le réinstaller à chaque déploiement ?? parce que j'ai essayé de le faire sur mon ancien code mais cela n'a pas fonctionné.

Mais mon plus gros problème vient de la connexion de la socket au server qui ne s'établit pas : socket error : "Unknown error"

BoxClient.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
//initialisation du client
void BoxClient::InitClient(QString remoteServername)
{
    m_socket = new QLocalSocket();
    m_serverName = remoteServername;
	m_socket->connectToServer(m_serverName);
	if (m_socket->waitForConnected(1000))
		qDebug("Connected!");
	else
		qDebug() << "socket error : " <<m_socket->errorString();
 
	connect(m_socket, SIGNAL(connected()), this, SLOT(socket_connected()));
    connect(m_socket, SIGNAL(disconnected()), this, SLOT(socket_disconnected()));
    connect(m_socket, SIGNAL(readyRead()), this, SLOT(socket_ReadyRead()));
    connect(m_socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(socket_error(QLocalSocket::LocalSocketError)));
 
	if(m_socket->error())
	{
		qDebug() << "socket state : "<<m_socket->state();
		if(m_socket->state() == QLocalSocket::UnconnectedState)
			qDebug() << "socket error : " <<m_socket->errorString();
	}
 
 
}

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

BoxClient::getInstance()->InitClient("local");

Donc normalement le serveur est lancé, mais la socket ne se connecte pas !
Je pense que le code est bon mais la je vois pas !

si tu as une idée là-dessus ?

je te remercie !!

[superjaja]

Je comprends pas trop en fait ton problème. Moi avec le serveur que je t'ai donné et l'appli graphique client que j'ai fait (voir poste plus haut) et bien tout fonctionne sous windows XP pro. J'ai aucun problème ou erreur. Les connexions passes super bien.

Sous quel plateforme es tu ?
Explique exactement la procédure qui fait que ton code bug, comment tu reproduis le truc ??
Donne tout le code de tes classes serveurs et clients...

[kek's]

Je suis sur Xp pro aussi !

je t'explique : lorsque je lance mon exe client, je déclare ma socket, ensuite je la connecte au serveur avec connectToServer(nom serveur) et ensuite je teste s'il attend la connection ou s'il y a une erreur !

voici le client.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
#include <QtNetwork>
 
#include "Socket.h"
 
 
 Socket::Socket()
 {
 
     socket = new QLocalSocket(this);
     requestNewFortune();
     connect(socket, SIGNAL(readyRead()), this, SLOT(readFortune()));
     connect(socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(displayError(QLocalSocket::LocalSocketError)));
 
 }
 
 void Socket::requestNewFortune()
 {
     blockSize = 0;
     socket->abort();
     socket->connectToServer("local");
	 if (socket->waitForConnected(1000))
		qDebug("Connected!");
	else
		qDebug() << "socket error : " <<socket->errorString();
 }
 
 void Socket::readFortune()
 {
     QDataStream in(socket);
     in.setVersion(QDataStream::Qt_4_0);
 
     if (blockSize == 0) {
         if (socket->bytesAvailable() < (int)sizeof(quint16))
             return;
         in >> blockSize;
     }
 
     if (in.atEnd())
         return;
 
     QString nextFortune;
     in >> nextFortune;
 
     if (nextFortune == currentFortune) {
         QTimer::singleShot(0, this, SLOT(requestNewFortune()));
         return;
     }
 
     currentFortune = nextFortune;
 }
 
 void Socket::displayError(QLocalSocket::LocalSocketError socketError)
 {
     switch (socketError) {
     case QLocalSocket::ServerNotFoundError:
        qDebug() << "The host was not found. Please check the host name and port settings.";
         break;
     case QLocalSocket::ConnectionRefusedError:
         qDebug() << "The connection was refused by the peer.Make sure the fortune server is running, and check that the host name and port settings are correct.";
         break;
     case QLocalSocket::PeerClosedError:
         break;
     default:
         qDebug() << "The following error occurred: %1.";
     }
 
 }

Voici le main.cpp côté client

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
 
#include <QtCore/QCoreApplication>
 #include <QByteArray>
 
#include "DatabaseManager.h"
#include "SqlManager.h"
#include "BoxClient.h"
#include "Socket.h"
 
int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);
 
	QByteArray BlockData;
 
	Socket::getInstance();
	SqlManager::getInstance()->saveToDatabase();
 
	return a.exec();
}

voici le Server.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
#include "Localserver.h"
 
#include <QtCore/QCoreApplication>
#include <QTimer>
 
 
LocalServer::LocalServer(QObject *parent) :
    QObject(parent) , m_server(this)
{
}
 
 
LocalServer::LocalServer(QString serverName) : m_server(this)
{
    connect(&this->m_server,SIGNAL(newConnection()),this,SLOT(NewConnectionOnServer()));
 
    if( !this->m_server.listen(serverName))
    {
       qDebug() << "Problème le server [" << serverName << "] est déjà à l'écoute..." ;
       QTimer::singleShot(2000, QCoreApplication::instance(), SLOT(quit()));
    }
    else
    {
       qDebug() << "Installation du serveur [" << serverName << "]" ;
    }
}
 
 
void LocalServer::NewConnectionOnServer()
{
    if(this->m_server.hasPendingConnections() == true)
    {
       QLocalSocket* client =  this->m_server.nextPendingConnection();
       connect(client,SIGNAL(readyRead()),this,SLOT(ReadOK()));
 
      qDebug() << "Nouvelle connexion sur le serveur ";
    }
}
 
void LocalServer::ReadOK()
{
    QLocalSocket* client = qobject_cast<QLocalSocket*>(sender());
 
    QString str = client->readAll();
 
   qDebug()<< QString("##: " + str +"\n");
 
}

et voici le main.cpp côté serveur

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
#include <QtCore/QCoreApplication>
#include <QLocalServer>
 
#include "MessagingSystemSerial.h"
#include "SerialDevice.h"
#include "BoxServer.h"
#include "LocalServer.h"
 
#define SERVER_NAME "local"
#define SVN "$Rev: 643 $"
 
int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);
 
	//Initialisation du serveur	
	LocalServer server(SERVER_NAME);
 
	//Revision SVN
 
	QString rev(SVN);
		rev = rev.replace(" $","").replace("$Rev: ","");
		a.setApplicationVersion("2.5." + rev);
 
	// mise en route du thread pour la récupération de données
	MessagingSystemSerial::getInstance()->InitBOX();
 
	// recupération des messages
	MessagingSystemSerial::getInstance()->processMessages();
 
 
	return a.exec();
}

Voici mon code !
J'espère que tu as tout ce qu'il faut, je cherche une nouvelle solution de connexion de socket mais elles sont toutes similaires et donc c'est pour cela je ne sais pas pourquoi elle ne se connecte pas vu que le serveur est apparemment déjà en fonctionnement !
Donc la je bloque à fond merci de m'aider et super sympa de ta part !