Cześć :)
Mam aplikację okienkową w QT. Mam też klasę serwera. W okienku mam przycisk start, który w założeniu ma wystartować serwer. I tu jest problem w logice aplikacji. Chciałbym to połączyć przez signal-slot. Klasa serwera miałaby slot, a sygnałem byłoby wciśnięcie przycisku. Teraz tylko, jak to zoorganizować?
Obiekt serwera tworzę w main.cpp. Nie będę przecież tworzył obiketu serwera w pliku mainwindow.cpp. Jeżeli tworzyłbym tu, to sprawa byłaby jasna.
- Rejestracja:prawie 11 lat
- Ostatnio:prawie 9 lat
- Postów:199
0
C++ 
QT 
- Rejestracja:prawie 11 lat
- Ostatnio:ponad 3 lata
- Lokalizacja:Szczecin
- Postów:500
1
obiekt ten musi dziedziczyć po QObject i mieć macro Q_OBJECT w klasie, możesz podać pointer do niego do mainwindow i tam ustawić connecty z odpowiednimi widgetami, design słaby, ale na ten czas tyle masz
jak dla mnie MainWindow powinno trzymać server jeżeli nie łączysz do niego innych widgetów lub nie masz jakiegoś managera, który byłby łącznikiem z mainwindow
- Rejestracja:ponad 11 lat
- Ostatnio:ponad 4 lata
- Postów:2442
0
Pisałem ostatnio dosyć mocno rozwinięty serwer i pisałem to dokładnie tak jak kolega wyżej. Napisałem klasę serwera z listą zawierającą obiekty QSSLSocket. Następnie dopisałem do tego graficzny interfejs będący już osobną klasą i w tej klasie utworzyłem obiekt klasy serwera. Działa pięknie i nawet nie trzeba używać wielowątkowości (poprzez zastosowanie listy socketów).
edytowany 1x, ostatnio: grzesiek51114
- Rejestracja:ponad 11 lat
- Ostatnio:ponad 4 lata
- Postów:2442
1
Mam klasę serwera, która wygląda tak:
#ifndef SERWER_H
#define SERWER_H
#include <QSslSocket>
#include <QDataStream>
class Serwer : public QTcpServer
{
Q_OBJECT
public:
explicit Serwer(QObject *parent = 0);
void wyslijDane(QString ip, quint16 port, QString dane);
void fluszuj();
~Serwer();
signals:
void dodanoKlienta(QString ip, quint16 port);
void usunietoKlienta(QString ip, quint16 port);
void odczytanoDane(QString dane);
private slots:
void usunKlienta();
void odczytajDane();
private:
void incomingConnection(int socketDescriptor);
QList<QSslSocket *> klienciSSL;
QString dane;
int index;
};
#endif // SERWER_H
Jej implementacja wygląda tak:
#include "serwer.h"
Serwer::Serwer(QObject *parent) :
QTcpServer(parent)
{
this->listen(QHostAddress::Any,82);
}
// FUNKCJA PUBLICZNA
void Serwer::wyslijDane(QString ip, quint16 port, QString dane){
for(int i=0;i<this->klienciSSL.length();i++){
if(klienciSSL[i]->peerAddress().toString() == ip && klienciSSL[i]->peerPort() == port){
index = i;
}
}
QByteArray blok;
QDataStream wyjscie(&blok,QIODevice::WriteOnly);
wyjscie.setVersion(QDataStream::Qt_5_1);
wyjscie << (quint16)0;
wyjscie << dane;
wyjscie.device()->seek(0);
wyjscie << (quint16)(blok.size() - sizeof(quint16));
this->klienciSSL[index]->write(blok);
}
// FUNKCJA PUBLICZNA
void Serwer::fluszuj(){
this->klienciSSL[this->index]->flush();
this->klienciSSL[this->index]->waitForReadyRead(30);
}
// SLOT
void Serwer::usunKlienta(){
QSslSocket *klient = qobject_cast<QSslSocket *>(this->sender());
if(klient){
emit this->usunietoKlienta(klient->peerAddress().toString(),klient->peerPort());
this->klienciSSL.removeAll(klient);
klient->deleteLater();
}
}
// SLOT
void Serwer::odczytajDane(){
QSslSocket *klient = qobject_cast<QSslSocket *>(this->sender());
if(klient){
QDataStream wejscie(klient);
wejscie.setVersion(QDataStream::Qt_5_1);
quint16 blok = 0;
if(blok == 0){
if(klient->bytesAvailable() < (int)sizeof(quint16))
return;
wejscie >> blok;
}
if(klient->bytesAvailable() < blok)
return;
wejscie >> this->dane;
emit this->odczytanoDane(this->dane);
if(klient->bytesAvailable())
this->odczytajDane();
}
}
// FUNKCJA PRYWATNA
void Serwer::incomingConnection(int socketDescriptor)
{
QSslSocket *serverSocket = new QSslSocket;
serverSocket->setPrivateKey("server.key");
serverSocket->setLocalCertificate("server.crt");
if (serverSocket->setSocketDescriptor(socketDescriptor)) {
this->klienciSSL.push_back(serverSocket);
connect(serverSocket,SIGNAL(disconnected()),this,SLOT(usunKlienta()));
connect(serverSocket,SIGNAL(readyRead()),this,SLOT(odczytajDane()));
connect(serverSocket,SIGNAL(encrypted()),serverSocket,SIGNAL(readyRead()));
serverSocket->startServerEncryption();
emit this->dodanoKlienta(serverSocket->peerAddress().toString(),serverSocket->peerPort());
}
else {
delete serverSocket;
}
}
Serwer::~Serwer()
{
this->klienciSSL.clear();
this->close();
}
I teraz w oknie głównym (GUI) mam proszę Ciebie taką oto gammę connectów gdzie this->srv to wskaźnik na obiekt klasy Serwer:
connect(this->srv,SIGNAL(dodanoKlienta(QString,quint16)),this,SLOT(dodajKlienta(QString,quint16)));
connect(this->srv,SIGNAL(usunietoKlienta(QString,quint16)),this,SLOT(usunKlienta(QString,quint16)));
connect(this->srv,SIGNAL(odczytanoDane(QString)),this,SLOT(interpretujDane(QString)));
Oprogramowałem całą komunikację na znacznikach, które są interpretowane w funkcji 'interpretujDane(QString)' każdego z okien, które musi komunikować się serwerem. Do każdego z okien przekazuję w/w wskaźnik dzięki czemu komunikacja jest możliwa. Trzeba tylko uważać, żeby te same connecty się nie powtarzały, bo wtedy serwer wykona tę samą czynność wielokrotnie. Trzeba też obsłużyć timeouty połączenia TCP przez np. przez cykliczne wysyłanie pakietu '<hello>' etc. Generalnie klient z każdym znacznikiem wysyła swoje gniazdo dzięki czemu serwer wie komu co ma odesłać.
W funkcji intrepretujDane(QString dane) może być np takie coś:
if(dane=="<blablalba>"){
this->ui->label->setText("blablabla");
}
PS: Pierwsze dwa connecty nie są priorytetowe. Funkcje te realizują dla mnie wrzucanie danych o gnieździe do tabeli, dzięki czemu widzę aktywnych klientów. Można je pominąć.
edytowany 4x, ostatnio: grzesiek51114
grzesiek51114