QWebSocket Class

Documentation des fonctions membres

[explicit] QWebSocket::QWebSocket(const QString &origin = QString(), QWebSocketProtocol::Version version = QWebSocketProtocol::VersionLatest, QObject *parent = nullptr)

Crée une nouvelle QWebSocket avec origin, version du protocole à utiliser et parent.

Le origin du client est tel que spécifié dans la RFC 6454. (Le origin n'est pas nécessaire pour les clients qui ne sont pas des navigateurs web (voir RFC 6455)). L'adresse origin ne doit pas contenir de caractères de nouvelle ligne, sinon la connexion sera interrompue immédiatement pendant la phase d'établissement de la liaison (handshake).

[override virtual noexcept] QWebSocket::~QWebSocket()

Détruit le site QWebSocket. Ferme le socket s'il est encore ouvert et libère les ressources utilisées.

void QWebSocket::abort()

Abandonne la socket en cours et réinitialise la socket. Contrairement à close(), cette fonction ferme immédiatement la socket, en rejetant toutes les données en attente dans le tampon d'écriture.

[signal] void QWebSocket::aboutToClose()

Ce signal est émis lorsque la socket est sur le point de se fermer. Connectez ce signal si vous avez des opérations qui doivent être effectuées avant la fermeture de la socket (par exemple, si vous avez des données dans un tampon séparé qui doivent être écrites sur le périphérique).

Voir aussi close().

[signal, since 6.2] void QWebSocket::alertReceived(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)

QWebSocket émet ce signal si un message d'alerte a été reçu d'un homologue. level indique si l'alerte était fatale ou s'il s'agissait d'un avertissement. type est le code expliquant pourquoi l'alerte a été envoyée. Lorsqu'une description textuelle du message d'alerte est disponible, elle est fournie dans description.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi alertSent(), QSsl::AlertLevel, et QSsl::AlertType.

[signal, since 6.2] void QWebSocket::alertSent(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)

QWebSocket émet ce signal si un message d'alerte a été envoyé à un homologue. level indique s'il s'agit d'un avertissement ou d'une erreur fatale. type donne le code du message d'alerte. Lorsqu'une description textuelle du message d'alerte est disponible, elle est fournie dans description.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi alertReceived(), QSsl::AlertLevel, et QSsl::AlertType.

[signal, since 6.6] void QWebSocket::authenticationRequired(QAuthenticator *authenticator)

Ce signal est émis lorsque le serveur demande une authentification. L'objet authenticator doit alors être rempli avec les détails requis pour permettre l'authentification et poursuivre la connexion.

Si vous savez que le serveur peut exiger une authentification, vous pouvez définir le nom d'utilisateur et le mot de passe sur l'objet initial QUrl, en utilisant QUrl::setUserName et QUrl::setPassword. QWebSocket essaiera quand même de se connecter une fois sans utiliser les informations d'identification fournies.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi QAuthenticator.

[signal] void QWebSocket::binaryFrameReceived(const QByteArray &frame, bool isLastFrame)

Ce signal est émis à chaque fois qu'une trame binaire est reçue. frame contient les données et isLastFrame indique s'il s'agit de la dernière trame du message complet.

Ce signal peut être utilisé pour traiter des messages volumineux image par image, au lieu d'attendre l'arrivée du message complet.

Voir aussi textFrameReceived().

[signal] void QWebSocket::binaryMessageReceived(const QByteArray &message)

Ce signal est émis lors de la réception d'un message binaire. Le message message contient les octets reçus.

Voir aussi textMessageReceived().

qint64 QWebSocket::bytesToWrite() const

Renvoie le nombre d'octets en attente d'écriture. Les octets sont écrits lorsque le contrôle revient à la boucle d'événements ou lorsque flush() est appelé.

Voir également flush.

[signal] void QWebSocket::bytesWritten(qint64 bytes)

Ce signal est émis à chaque fois qu'un paquet de données a été écrit sur la socket. L'argument bytes correspond au nombre d'octets qui ont été écrits dans cette charge.

Voir également close().

[slot] void QWebSocket::close(QWebSocketProtocol::CloseCode closeCode = QWebSocketProtocol::CloseCodeNormal, const QString &reason = QString())

Ferme gracieusement la socket avec les valeurs données closeCode et reason.

Toutes les données contenues dans le tampon d'écriture sont effacées avant la fermeture de la socket. Le closeCode est un QWebSocketProtocol::CloseCode indiquant la raison de la fermeture, et le reason décrit la raison de la fermeture plus en détail. Toutes les trames de contrôle, y compris la trame Close, sont limitées à 125 octets. Comme deux d'entre eux sont utilisés pour closeCode, la longueur maximale de reason est de 123 ! Si reason dépasse cette limite, il sera tronqué.

QWebSocketProtocol::CloseCode QWebSocket::closeCode() const

Renvoie le code indiquant pourquoi la socket a été fermée.

Voir aussi QWebSocketProtocol::CloseCode et closeReason().

QString QWebSocket::closeReason() const

Renvoie la raison pour laquelle la socket a été fermée.

Voir aussi closeCode().

[signal] void QWebSocket::connected()

Emis lorsqu'une connexion est établie avec succès. Une connexion est établie avec succès lorsque la socket est connectée et que le handshake a réussi.

Voir également open() et disconnected().

[since 6.2] void QWebSocket::continueInterruptedHandshake()

Si une application souhaite conclure une poignée de main même après avoir reçu le signal handshakeInterruptedOnError(), elle doit appeler cette fonction. Cet appel doit être fait à partir d'une fonction slot attachée au signal. La connexion signal-slot doit être directe.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi handshakeInterruptedOnError() et QSslConfiguration::setHandshakeMustInterruptOnError().

[signal] void QWebSocket::disconnected()

Emis lorsque le socket est déconnecté.

Voir aussi close() et connected().

QAbstractSocket::SocketError QWebSocket::error() const

Renvoie le type d'erreur qui s'est produite en dernier

Voir aussi errorString().

[signal, since 6.5] void QWebSocket::errorOccurred(QAbstractSocket::SocketError error)

Ce signal est émis lorsqu'une erreur s'est produite.

Le paramètre error décrit le type d'erreur qui s'est produite.

QAbstractSocket::SocketError n'est pas un métatype enregistré, donc pour les connexions en file d'attente, vous devrez l'enregistrer avec Q_DECLARE_METATYPE() et qRegisterMetaType().

Cette fonction a été introduite dans Qt 6.5.

Voir aussi error() et errorString().

QString QWebSocket::errorString() const

Renvoie une description lisible par l'homme de la dernière erreur qui s'est produite

Voir aussi error().

bool QWebSocket::flush()

Cette fonction écrit autant de données que possible depuis le tampon d'écriture interne vers le socket réseau sous-jacent, sans bloquer. Si des données ont été écrites, cette fonction renvoie true ; sinon, elle renvoie false. Appelez cette fonction si vous avez besoin que QWebSocket commence à envoyer des données tamponnées immédiatement. Le nombre d'octets écrits avec succès dépend du système d'exploitation. Dans la plupart des cas, il n'est pas nécessaire d'appeler cette fonction, car QWebSocket commencera à envoyer des données automatiquement dès que le contrôle reviendra à la boucle d'événements.

[signal, since 6.2] void QWebSocket::handshakeInterruptedOnError(const QSslError &error)

QWebSocket émet ce signal si une erreur de vérification de certificat a été trouvée et si le rapport d'erreur précoce a été activé dans QSslConfiguration. Une application est censée inspecter le site error et décider si elle souhaite poursuivre la poignée de main ou l'interrompre et envoyer un message d'alerte à l'homologue. La connexion signal-slot doit être directe.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi continueInterruptedHandshake(), sslErrors(), et QSslConfiguration::setHandshakeMustInterruptOnError().

[since 6.4] QWebSocketHandshakeOptions QWebSocket::handshakeOptions() const

Renvoie les options de la poignée de main qui ont été utilisées pour ouvrir cette socket.

Cette fonction a été introduite dans Qt 6.4.

[slot] void QWebSocket::ignoreSslErrors()

Ce slot indique à QWebSocket d'ignorer les erreurs pendant la phase de poignée de main de QWebSocket et de poursuivre la connexion. Si vous souhaitez poursuivre la connexion même si des erreurs surviennent pendant la phase de poignée de main, vous devez appeler ce slot, soit à partir d'un slot connecté à sslErrors(), soit avant la phase de poignée de main. Si vous n'appelez pas ce slot, que ce soit en réponse à des erreurs ou avant la poignée de main, la connexion sera interrompue après l'émission du signal sslErrors().

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload<>(&QWebSocket::ignoreSslErrors));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket]() { receiver->ignoreSslErrors(); });

Voir aussi sslErrors(), QSslSocket::ignoreSslErrors(), et QNetworkReply::ignoreSslErrors().

void QWebSocket::ignoreSslErrors(const QList<QSslError> &errors)

Cette méthode indique à QWebSocket d'ignorer les erreurs données dans errors.

Notez que vous pouvez définir le certificat attendu dans l'erreur SSL : Si, par exemple, vous voulez vous connecter à un serveur qui utilise un certificat auto-signé, considérez l'extrait suivant :

QList<QSslCertificate> cert = QSslCertificate::fromPath(QLatin1String("server-certificate.pem"));
QSslError error(QSslError::SelfSignedCertificate, cert.at(0));
QList<QSslError> expectedSslErrors;
expectedSslErrors.append(error);

QWebSocket socket;
socket.ignoreSslErrors(expectedSslErrors);
socket.open(QUrl(QStringLiteral("wss://myserver.at.home")));

Plusieurs appels à cette fonction remplaceront la liste des erreurs transmises lors des appels précédents. Vous pouvez effacer la liste des erreurs que vous souhaitez ignorer en appelant cette fonction avec une liste vide.

Voir aussi sslErrors().

bool QWebSocket::isValid() const

Renvoie true si la socket est prête pour la lecture et l'écriture ; sinon, renvoie false.

QHostAddress QWebSocket::localAddress() const

Renvoie l'adresse locale

quint16 QWebSocket::localPort() const

Renvoie le port local

const QMaskGenerator *QWebSocket::maskGenerator() const

Renvoie le générateur de masque actuellement utilisé par ce site QWebSocket.

Voir aussi setMaskGenerator().

quint64 QWebSocket::maxAllowedIncomingFrameSize() const

Renvoie la taille maximale autorisée d'une trame websocket entrante.

Voir aussi setMaxAllowedIncomingFrameSize().

quint64 QWebSocket::maxAllowedIncomingMessageSize() const

Renvoie la taille maximale autorisée d'un message websocket entrant.

Voir aussi setMaxAllowedIncomingMessageSize().

[static] quint64 QWebSocket::maxIncomingFrameSize()

Renvoie la taille maximale supportée d'une trame websocket entrante pour cette implémentation websocket.

[static] quint64 QWebSocket::maxIncomingMessageSize()

Renvoie la taille maximale supportée d'un message websocket entrant pour cette implémentation websocket.

[static] quint64 QWebSocket::maxOutgoingFrameSize()

Renvoie la taille maximale supportée d'une trame websocket sortante pour cette implémentation websocket.

[slot] void QWebSocket::open(const QNetworkRequest &request)

Ouvre une connexion WebSocket en utilisant l'adresse request.

L'url request sera utilisée pour ouvrir la connexion WebSocket. Les en-têtes présents dans la requête seront envoyés au serveur dans la requête de mise à niveau, ainsi que ceux nécessaires à l'établissement de la connexion WebSocket.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QNetworkRequest &request) { receiver->open(request); });

[slot] void QWebSocket::open(const QUrl &url)

Ouvre une connexion WebSocket en utilisant l'adresse url.

Si l'url contient des caractères de retour à la ligne (\r\n ), le signal d'erreur sera émis avec QAbstractSocket::ConnectionRefusedError comme type d'erreur.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QUrl &url) { receiver->open(url); });

[slot, since 6.4] void QWebSocket::open(const QNetworkRequest &request, const QWebSocketHandshakeOptions &options)

Ouvre une connexion WebSocket en utilisant les adresses request et options.

L'url request sera utilisée pour ouvrir la connexion WebSocket. Les en-têtes présents dans la requête seront envoyés au serveur dans la requête de mise à niveau, ainsi que ceux nécessaires à l'établissement de la connexion WebSocket.

Des options supplémentaires pour la poignée de main WebSocket, telles que les sous-protocoles, peuvent être spécifiées à l'adresse options.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QNetworkRequest &request, const QWebSocketHandshakeOptions &options) { receiver->open(request, options); });

Cette fonction a été introduite dans Qt 6.4.

[slot, since 6.4] void QWebSocket::open(const QUrl &url, const QWebSocketHandshakeOptions &options)

Ouvre une connexion WebSocket en utilisant les adresses url et options.

Si l'url contient des caractères de retour à la ligne (\r\n ), le signal d'erreur sera émis avec QAbstractSocket::ConnectionRefusedError comme type d'erreur.

Des options supplémentaires pour la poignée de main WebSocket, telles que les sous-protocoles, peuvent être spécifiées à l'adresse options.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QUrl &url, const QWebSocketHandshakeOptions &options) { receiver->open(url, options); });

Cette fonction a été introduite dans Qt 6.4.

QString QWebSocket::origin() const

Renvoie l'origine actuelle.

quint64 QWebSocket::outgoingFrameSize() const

Renvoie la taille maximale d'une trame websocket sortante.

Voir aussi setOutgoingFrameSize().

QAbstractSocket::PauseModes QWebSocket::pauseMode() const

Renvoie le mode de pause de cette socket

Voir aussi setPauseMode().

QHostAddress QWebSocket::peerAddress() const

Renvoie l'adresse de l'homologue

QString QWebSocket::peerName() const

Renvoie le nom de l'homologue

quint16 QWebSocket::peerPort() const

Retourne le peerport

[signal, since 6.2] void QWebSocket::peerVerifyError(const QSslError &error)

QWebSocket peut émettre ce signal plusieurs fois au cours de la poignée de main SSL, avant que le cryptage n'ait été établi, pour indiquer qu'une erreur s'est produite lors de l'établissement de l'identité de l'homologue. Le signal error indique généralement que QWebSocket n'est pas en mesure d'identifier l'homologue de manière sécurisée.

Ce signal vous permet de savoir rapidement si quelque chose ne va pas. En vous connectant à ce signal, vous pouvez choisir manuellement de couper la connexion à partir du slot connecté avant que la poignée de main ne soit terminée. Si aucune action n'est entreprise, QWebSocket émettra QWebSocket::sslErrors().

Cette fonction a été introduite dans Qt 6.2.

Voir aussi sslErrors().

[slot] void QWebSocket::ping(const QByteArray &payload = QByteArray())

Effectue un ping sur le serveur pour indiquer que la connexion est toujours en cours. Un payload supplémentaire peut être envoyé avec le message ping.

La taille de payload ne peut être supérieure à 125 octets. Si elle est plus grande, la taille de payload est réduite à 125 octets.

Voir aussi pong().

[signal] void QWebSocket::pong(quint64 elapsedTime, const QByteArray &payload)

Émis lorsqu'un message pong est reçu en réponse à un ping précédent. elapsedTime contient le temps d'aller-retour en millisecondes et payload contient une charge utile facultative qui a été envoyée avec le ping.

Voir aussi ping().

[signal] void QWebSocket::preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator)

Ce signal est émis si la poignée de main SSL/TLS négocie une suite de chiffrement PSK et qu'une authentification PSK est donc nécessaire.

Lors de l'utilisation de la PSK, le client doit envoyer au serveur une identité valide et une clé pré-partagée valide, afin que la poignée de main SSL puisse se poursuivre. Les applications peuvent fournir ces informations dans un slot connecté à ce signal, en remplissant l'objet authenticator en fonction de leurs besoins.

Voir aussi QSslPreSharedKeyAuthenticator et QSslSocket::preSharedKeyAuthenticationRequired().

QNetworkProxy QWebSocket::proxy() const

Renvoie le proxy actuellement configuré

Voir aussi setProxy().

[signal] void QWebSocket::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)

Ce signal peut être émis lors de l'utilisation d'un site proxy nécessitant une authentification. L'objet authenticator peut alors être rempli avec les détails requis pour permettre l'authentification et poursuivre la connexion.

Voir également QAuthenticator et QNetworkProxy.

qint64 QWebSocket::readBufferSize() const

Renvoie la taille en octets du tampon de lecture utilisé par la socket.

Voir aussi setReadBufferSize().

[signal] void QWebSocket::readChannelFinished()

Ce signal est émis lorsque le flux d'entrée (lecture) est fermé dans ce dispositif. Il est émis dès que la fermeture est détectée.

Voir aussi close().

QNetworkRequest QWebSocket::request() const

Renvoie la requête qui a été ou sera utilisée pour ouvrir cette socket.

QUrl QWebSocket::requestUrl() const

Renvoie l'url à laquelle la socket est connectée ou se connectera.

QString QWebSocket::resourceName() const

Renvoie le nom de la ressource à laquelle on accède actuellement.

void QWebSocket::resume()

Poursuit le transfert de données sur la socket. Cette méthode ne doit être utilisée qu'après que la socket a été configurée pour faire une pause en cas de notification et qu'une notification a été reçue. La seule notification actuellement supportée est sslErrors(). L'appel de cette méthode si la socket n'est pas en pause entraîne un comportement indéfini.

Voir aussi pauseMode() et setPauseMode().

qint64 QWebSocket::sendBinaryMessage(const QByteArray &data)

Envoie l'adresse data sur la socket sous la forme d'un message binaire et renvoie le nombre d'octets effectivement envoyés.

Voir aussi sendTextMessage().

qint64 QWebSocket::sendTextMessage(const QString &message)

Envoie l'adresse message sur la socket sous forme de message texte et renvoie le nombre d'octets effectivement envoyés.

Voir aussi sendBinaryMessage().

void QWebSocket::setMaskGenerator(const QMaskGenerator *maskGenerator)

Définit le générateur à utiliser pour créer des masques à maskGenerator. Le générateur par défaut QWebSocket peut être réinitialisé en fournissant un nullptr. Le générateur de masque peut être modifié à tout moment, même lorsque la connexion est ouverte.

Voir aussi maskGenerator().

void QWebSocket::setMaxAllowedIncomingFrameSize(quint64 maxAllowedIncomingFrameSize)

Fixe la taille maximale autorisée d'une trame websocket entrante à maxAllowedIncomingFrameSize. Si une trame entrante dépasse cette limite, l'homologue est déconnecté. La plage acceptée est comprise entre 0 et maxIncomingFrameSize(), la valeur par défaut étant maxIncomingFrameSize(). Le but de cette fonction est d'éviter d'épuiser la mémoire virtuelle.

Voir aussi maxAllowedIncomingFrameSize().

void QWebSocket::setMaxAllowedIncomingMessageSize(quint64 maxAllowedIncomingMessageSize)

Fixe la taille maximale autorisée d'un message websocket entrant à maxAllowedIncomingMessageSize. Si un message entrant dépasse cette limite, l'homologue est déconnecté. La plage acceptée est comprise entre 0 et maxIncomingMessageSize(), la valeur par défaut étant maxIncomingMessageSize(). Le but de cette fonction est d'éviter d'épuiser la mémoire virtuelle.

Voir aussi maxAllowedIncomingMessageSize().

void QWebSocket::setOutgoingFrameSize(quint64 outgoingFrameSize)

Fixe la taille maximale d'une trame websocket sortante à outgoingFrameSize. La plage acceptée est comprise entre 0 et maxOutgoingFrameSize(), la valeur par défaut est de 512 Ko. Le but de cette fonction est de s'adapter à la taille de trame maximale autorisée par le récepteur.

Voir aussi outgoingFrameSize().

void QWebSocket::setPauseMode(QAbstractSocket::PauseModes pauseMode)

Détermine s'il convient de faire une pause lors de la réception d'une notification. Le paramètre pauseMode spécifie les conditions dans lesquelles la socket doit être mise en pause.

La seule notification actuellement supportée est sslErrors(). Si l'option est définie sur PauseOnSslErrors, le transfert de données sur la socket sera interrompu et devra être réactivé explicitement en appelant resume(). Par défaut, cette option est définie sur PauseNever. Cette option doit être appelée avant la connexion au serveur, sous peine de provoquer un comportement indéfini.

Voir également pauseMode() et resume().

void QWebSocket::setProxy(const QNetworkProxy &networkProxy)

Définit le proxy à networkProxy

Voir aussi proxy().

void QWebSocket::setReadBufferSize(qint64 size)

Fixe la taille du tampon de lecture interne de QWebSocket à size octets.

Si la taille du tampon est limitée à une certaine taille, QWebSocket ne mettra pas en mémoire tampon plus que cette taille de données. Exceptionnellement, une taille de tampon de 0 signifie que le tampon de lecture est illimité et que toutes les données entrantes sont mises en mémoire tampon. Il s'agit de la valeur par défaut. Cette option est utile si vous ne lisez les données qu'à certains moments (par exemple, dans une application de streaming en temps réel) ou si vous voulez protéger votre socket contre la réception d'une trop grande quantité de données, ce qui pourrait éventuellement entraîner une saturation de la mémoire de votre application.

Voir aussi readBufferSize().

void QWebSocket::setSslConfiguration(const QSslConfiguration &sslConfiguration)

Définit la configuration SSL de la socket comme étant le contenu de sslConfiguration.

Cette fonction définit le certificat local, les algorithmes de chiffrement, la clé privée et les certificats d'autorité de certification comme étant ceux stockés dans sslConfiguration. Il n'est pas possible de définir les champs liés à l'état SSL.

Voir aussi sslConfiguration().

QSslConfiguration QWebSocket::sslConfiguration() const

Renvoie l'état de la configuration SSL de la socket. La configuration SSL par défaut d'une socket consiste à utiliser les algorithmes de chiffrement par défaut, les certificats d'autorité de certification par défaut, aucune clé privée locale ni aucun certificat. La configuration SSL contient également des champs qui peuvent changer avec le temps sans préavis.

Voir aussi setSslConfiguration().

[signal] void QWebSocket::sslErrors(const QList<QSslError> &errors)

QWebSocket émet ce signal après la poignée de main SSL pour indiquer qu'une ou plusieurs erreurs se sont produites lors de l'établissement de l'identité de l'homologue. Ces erreurs indiquent généralement que QWebSocket n'est pas en mesure d'identifier l'homologue de manière sécurisée. Si aucune mesure n'est prise, la connexion sera interrompue après l'émission de ce signal. Si vous voulez continuer à vous connecter malgré les erreurs qui se sont produites, vous devez appeler QWebSocket::ignoreSslErrors() à partir d'un slot connecté à ce signal. Si vous devez accéder à la liste des erreurs ultérieurement, vous pouvez appeler sslErrors() (sans arguments).

errors contient une ou plusieurs erreurs qui empêchent QWebSocket de vérifier l'identité de l'homologue.

QAbstractSocket::SocketState QWebSocket::state() const

Renvoie l'état actuel de la socket.

[signal] void QWebSocket::stateChanged(QAbstractSocket::SocketState state)

Ce signal est émis lorsque l'état de QWebSocket change. Le paramètre state correspond au nouvel état.

QAbstractSocket::SocketState n'est pas un métatype enregistré, donc pour les connexions en file d'attente, vous devrez l'enregistrer avec Q_REGISTER_METATYPE() et qRegisterMetaType().

Voir également state().

[since 6.4] QString QWebSocket::subprotocol() const

Renvoie le protocole WebSocket utilisé.

Cette fonction a été introduite dans Qt 6.4.

[signal] void QWebSocket::textFrameReceived(const QString &frame, bool isLastFrame)

Ce signal est émis à chaque fois qu'une trame de texte est reçue. frame contient les données et isLastFrame indique s'il s'agit de la dernière trame du message complet.

Ce signal peut être utilisé pour traiter des messages volumineux image par image, au lieu d'attendre que le message complet arrive.

Voir aussi binaryFrameReceived().

[signal] void QWebSocket::textMessageReceived(const QString &message)

Ce signal est émis lors de la réception d'un message texte. Le message message contient le texte reçu.

Voir aussi binaryMessageReceived().

QWebSocketProtocol::Version QWebSocket::version() const

Renvoie la version que la socket utilise actuellement.