Initialisation de QLocalServer

Version imprimable

Voir 40 message(s) de cette discussion en une page

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:

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!

20/01/2011, 11h30
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:

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 !
20/01/2011, 12h45
superjaja

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

Bonjour superjaja,

Code:

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 !

20/01/2011, 17h52
superjaja

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

Ex :

Code:

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

A mon avis fait plutot ça :

Code:

BoxServer server("local");

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

Code:

server->serverName() = NomServeur;

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

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:

server->serverName() = NomServeur;

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

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:

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:

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 !

21/01/2011, 13h00
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 ?
21/01/2011, 15h17
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 !
24/01/2011, 12h54
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...
24/01/2011, 16h57
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. :ccool:

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:

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 !

25/01/2011, 12h43
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.
25/01/2011, 13h56
superjaja

1 pièce(s) jointe(s)

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.

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:

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:

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:

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 !!

25/01/2011, 17h43
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.

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:

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 !

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:

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:

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:

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 ??

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:

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:

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 !!

31/01/2011, 10h49
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...

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:

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:

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:

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:

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 !
:ccool:

Voir 40 message(s) de cette discussion en une page