QWebSocket Class

Documentation des fonctions membres

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

Crée un nouvel objet QWebSocket avec l'origin, l'version du protocole à utiliser et parent.

L'origin du client est conforme à la spécification de la RFC 6454. (L'origin n'est pas obligatoire pour les clients autres que les navigateurs Web (voir RFC 6455)). L'origin ne doit pas contenir de caractères de nouvelle ligne, sous peine de voir la connexion interrompue immédiatement pendant la phase d'établissement de la connexion.

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

Supprime l'QWebSocket. Ferme le socket s'il est encore ouvert et libère toutes les ressources utilisées.

void QWebSocket::abort()

Annule l'opération en cours sur le socket et réinitialise celui-ci. Contrairement à la fonction ` close()`, cette fonction ferme immédiatement le socket, en supprimant 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-vous à ce signal si vous avez des opérations à effectuer avant la fermeture de la socket (par exemple, si vous disposez de données dans un tampon distinct qui doivent être écrites sur le périphérique).

Voir également 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 pair. ` 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 également 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 pair. level indique s’il s’agissait d’un avertissement ou d’une erreur fatale. type fournit 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 également alertReceived(), QSsl::AlertLevel et QSsl::AlertType.

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

Ce signal est émis lorsque le serveur exige une authentification. L'objet ` authenticator ` doit alors être renseigné avec les informations requises pour permettre l'authentification et poursuivre la connexion.

Si vous savez que le serveur est susceptible d'exiger une authentification, vous pouvez définir le nom d'utilisateur et le mot de passe dès la création initiale de l'QUrl, à l'aide des méthodes QUrl::setUserName et QUrl::setPassword. L'instance QWebSocket tentera tout de même de se connecter une fois sans utiliser les identifiants fournis.

Cette fonction a été introduite dans Qt 6.6.

Voir également QAuthenticator.

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

Ce signal est émis dès qu’une trame binaire est reçue. L’ frame contient les données et l’ isLastFrame indique s’il s’agit de la dernière trame du message complet.

Ce signal peut être utilisé pour traiter des messages volumineux trame par trame, au lieu d’attendre que le message complet soit reçu.

Voir également textFrameReceived().

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

Ce signal est émis chaque fois qu'un message binaire est reçu. La variable ` message ` contient les octets reçus.

Voir également textMessageReceived().

qint64 QWebSocket::bytesToWrite() const

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

Voir également flush.

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

Ce signal est émis chaque fois qu'une charge utile de données a été écrite dans le socket. L'argument ` bytes ` est défini sur le nombre d'octets qui ont été écrits dans cette charge utile.

Voir également close().

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

Ferme proprement le socket en utilisant les paramètres ` closeCode ` et ` reason` fournis.

Toutes les données présentes dans le tampon d’écriture sont vidées avant la fermeture du socket. L’ closeCode est un QWebSocketProtocol::CloseCode indiquant la raison de la fermeture, et reason décrit plus en détail cette raison. Toutes les trames de contrôle, y compris la trame « Close », sont limitées à 125 octets. Étant donné que deux d’entre eux sont utilisés pour l’ closeCode, la longueur maximale de reason est de 123 ! Si reason dépasse cette limite, elle sera tronquée.

QWebSocketProtocol::CloseCode QWebSocket::closeCode() const

Renvoie le code indiquant la raison pour laquelle le socket a été fermé.

Voir également QWebSocketProtocol::CloseCode et closeReason().

QString QWebSocket::closeReason() const

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

Voir également closeCode().

[signal] void QWebSocket::connected()

Émis lorsqu'une connexion est établie avec succès. Une connexion est considérée comme établie avec succès lorsque le socket est connecté et que la phase d'établissement de la connexion s'est déroulée correctement.

Voir également open() et disconnected().

[since 6.2] void QWebSocket::continueInterruptedHandshake()

Si une application souhaite mener à bien une négociation de connexion même après avoir reçu le sign handshakeInterruptedOnError(), elle doit appeler cette fonction. Cet appel doit être effectué depuis une fonction de slot associée au signal. La connexion signal-slot doit être directe.

Cette fonction a été introduite dans Qt 6.2.

Voir également ` handshakeInterruptedOnError()` et ` QSslConfiguration::setHandshakeMustInterruptOnError()`.

[signal] void QWebSocket::disconnected()

Généré lorsque la connexion est interrompue.

Voir aussi close() et connected().

QAbstractSocket::SocketError QWebSocket::error() const

Renvoie le type de l'erreur qui s'est produite en dernier

Voir également 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é ; par conséquent, pour les connexions en file d'attente, vous devrez l'enregistrer à l'aide des fonctions Q_DECLARE_METATYPE() et qRegisterMetaType().

Cette fonction a été introduite dans Qt 6.5.

Voir également error() et errorString().

QString QWebSocket::errorString() const

Renvoie une description compréhensible par l'utilisateur de la dernière erreur survenue

Voir aussi ` error()`.

bool QWebSocket::flush()

Cette fonction écrit autant de données que possible depuis le tampon d'écriture interne vers la socket réseau sous-jacente, sans blocage. Si des données ont été écrites, cette fonction renvoie « true » ; dans le cas contraire, elle renvoie « false ». Appelez cette fonction si vous souhaitez qu’ QWebSocket commence immédiatement à envoyer les données mises en mémoire tampon. Le nombre d’octets écrits avec succès dépend du système d’exploitation. Dans la plupart des cas, vous n’avez pas besoin d’appeler cette fonction, car QWebSocket commence automatiquement à envoyer les données dès que le contrôle revient à 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é détectée et si le signalement précoce des erreurs a été activé dans ` QSslConfiguration`. L'application doit alors examiner la variable ` error ` et décider si elle souhaite poursuivre la négociation de connexion ou l'interrompre et envoyer un message d'alerte au pair. La connexion signal-slot doit être directe.

Cette fonction a été introduite dans Qt 6.2.

Voir également continueInterruptedHandshake(), sslErrors() et QSslConfiguration::setHandshakeMustInterruptOnError().

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

Renvoie les options de négociation de connexion utilisées pour ouvrir ce socket.

Cette fonction a été introduite dans Qt 6.4.

[slot] void QWebSocket::ignoreSslErrors()

Ce slot indique à QWebSocket d'ignorer les erreurs survenant pendant la phase d'établissement de la connexion de QWebSocket et de poursuivre la connexion. Si vous souhaitez poursuivre la connexion même en cas d'erreurs pendant la phase d'établissement, vous devez appeler ce slot, soit depuis un slot lié à sslErrors(), soit avant la phase d'établissement. Si vous n’appelez pas ce slot, que ce soit en réponse à des erreurs ou avant l’établissement de la connexion, 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 également sslErrors(), QSslSocket::ignoreSslErrors() et QNetworkReply::ignoreSslErrors().

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

Cette méthode indique à QWebSocket d'ignorer les erreurs répertoriées sur errors.

Notez que vous pouvez définir le certificat attendu dans l'erreur SSL : si, par exemple, vous souhaitez vous connecter à un serveur utilisant un certificat auto-signé, considérez l'extrait de code 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")));

Les appels multiples à 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 également ` sslErrors()`.

bool QWebSocket::isValid() const

Renvoie ` true ` si le socket est prêt 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 masques actuellement utilisé par cet objet ` QWebSocket`.

Voir aussi setMaskGenerator().

quint64 QWebSocket::maxAllowedIncomingFrameSize() const

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

Voir également setMaxAllowedIncomingFrameSize().

quint64 QWebSocket::maxAllowedIncomingMessageSize() const

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

Voir également setMaxAllowedIncomingMessageSize().

[static] quint64 QWebSocket::maxIncomingFrameSize()

Renvoie la taille maximale prise en charge pour une trame WebSocket entrante dans le cadre de cette implémentation WebSocket.

[static] quint64 QWebSocket::maxIncomingMessageSize()

Renvoie la taille maximale prise en charge pour un message WebSocket entrant dans le cadre de cette implémentation WebSocket.

[static] quint64 QWebSocket::maxOutgoingFrameSize()

Renvoie la taille maximale prise en charge pour une trame WebSocket sortante dans le cadre de cette implémentation WebSocket.

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

Ouvre une connexion WebSocket à l'aide de l'URL request fournie.

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 d’upgrade, avec ceux nécessaires à la négociation 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 à l'aide de l'URL fournie url.

Si l'URL contient des caractères de saut de ligne (\r\n ), un 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 à l'aide des URL request et options fournies.

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 d'actualisation, avec ceux nécessaires à la négociation WebSocket.

Des options supplémentaires pour la négociation WebSocket, telles que les sous-protocoles, peuvent être spécifiées dans 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 à l'aide des adresses url et options fournies.

Si l'URL contient des caractères de saut de ligne (\r\n ), un signal d'erreur est alors émis avec QAbstractSocket::ConnectionRefusedError comme type d'erreur.

Des options supplémentaires pour la négociation WebSocket, telles que les sous-protocoles, peuvent être spécifiées dans ` 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 du pair

QString QWebSocket::peerName() const

Renvoie le peerName

quint16 QWebSocket::peerPort() const

Renvoie le port de communication

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

QWebSocket peut émettre ce signal à plusieurs reprises au cours de la négociation SSL, avant que le chiffrement ne soit établi, pour signaler qu'une erreur s'est produite lors de la vérification de l'identité du correspondant. L'error e indique généralement que QWebSocket n'est pas en mesure d'identifier le correspondant de manière sécurisée.

Ce signal vous fournit une alerte précoce en cas de problème. En vous connectant à ce signal, vous pouvez choisir manuellement de rompre la connexion depuis l’intérieur du slot « connected » avant que la négociation ne soit terminée. Si aucune action n’est entreprise, ` QWebSocket ` émettra alors ` QWebSocket::sslErrors()`.

Cette fonction a été introduite dans Qt 6.2.

Voir également sslErrors().

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

Envoie une requête « ping » au serveur pour indiquer que la connexion est toujours active. Une « payload » supplémentaire peut être envoyée en même temps que le message « ping ».

La taille de l’ payload ne doit pas dépasser 125 octets. Si elle est supérieure, l’ payload est tronquée à 125 octets.

Voir également 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. L'elapsedTime contient le temps aller-retour en millisecondes et l'payload contient une charge utile facultative qui a été envoyée avec le « ping ».

Voir également ping().

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

Ce signal est émis si la négociation SSL/TLS aboutit à un ensemble de chiffrements PSK, ce qui rend alors nécessaire une authentification PSK.

Lorsqu'il utilise la méthode PSK, le client doit envoyer au serveur une identité valide et une clé pré-partagée valide pour que la négociation SSL puisse se poursuivre. Les applications peuvent fournir ces informations dans un slot connecté à ce signal, en renseignant l'objet ` authenticator ` transmis selon leurs besoins.

Voir également 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 lorsqu'une connexion « proxy » nécessitant une authentification est utilisée. L'objet « authenticator » peut alors être renseigné avec les informations requises 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 également la fonction ` setReadBufferSize()`.

[signal] void QWebSocket::readChannelFinished()

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

Voir également close().

QNetworkRequest QWebSocket::request() const

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

QUrl QWebSocket::requestUrl() const

Renvoie l'URL à laquelle le socket est connecté ou à laquelle il va se connecter.

QString QWebSocket::resourceName() const

Renvoie le nom de la ressource actuellement consultée.

void QWebSocket::resume()

Poursuit le transfert de données sur le socket. Cette méthode ne doit être utilisée qu’après avoir configuré le socket pour qu’il se mette en pause à la réception d’une notification et qu’une notification ait effectivement été reçue. La seule notification actuellement prise en charge est sslErrors(). L’appel de cette méthode alors que le socket n’est pas en pause entraîne un comportement indéfini.

Voir également pauseMode() et setPauseMode().

qint64 QWebSocket::sendBinaryMessage(const QByteArray &data)

Envoie l'data on fournie via le socket sous forme de message binaire et renvoie le nombre d'octets effectivement envoyés.

Voir aussi sendTextMessage().

qint64 QWebSocket::sendTextMessage(const QString &message)

Envoie l'message on indiquée via le 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 sur maskGenerator. Le générateur par défaut QWebSocket peut être réinitialisé en fournissant un nullptr. Le générateur de masques peut être modifié à tout moment, même lorsque la connexion est ouverte.

Voir également maskGenerator().

void QWebSocket::setMaxAllowedIncomingFrameSize(quint64 maxAllowedIncomingFrameSize)

Définit la taille maximale autorisée d’une trame WebSocket entrante à maxAllowedIncomingFrameSize. Si une trame entrante dépasse cette limite, la connexion avec le pair est interrompue. La valeur acceptée est comprise entre 0 et maxIncomingFrameSize(), la valeur par défaut étant maxIncomingFrameSize(). Cette fonction a pour but d’éviter l’épuisement de la mémoire virtuelle.

Voir également maxAllowedIncomingFrameSize().

void QWebSocket::setMaxAllowedIncomingMessageSize(quint64 maxAllowedIncomingMessageSize)

Définit la taille maximale autorisée d'un message WebSocket entrant à maxAllowedIncomingMessageSize. Si un message entrant dépasse cette limite, la connexion avec le pair est interrompue. La valeur acceptée est comprise entre 0 et maxIncomingMessageSize(), la valeur par défaut étant maxIncomingMessageSize(). Cette fonction a pour but d'éviter l'épuisement de la mémoire virtuelle.

Voir également maxAllowedIncomingMessageSize().

void QWebSocket::setOutgoingFrameSize(quint64 outgoingFrameSize)

Définit la taille maximale d'une trame WebSocket sortante à outgoingFrameSize. La plage autorisée est comprise entre 0 et maxOutgoingFrameSize(), la valeur par défaut étant 512 ko. Cette fonction a pour but de s'adapter à la taille maximale autorisée des trames du destinataire.

Voir également outgoingFrameSize().

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

Détermine s'il faut mettre en pause le système à 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 prise en charge est sslErrors(). Si elle est définie sur PauseOnSslErrors, le transfert de données sur la socket sera mis en pause 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 de se connecter au serveur, sinon cela entraînera un comportement indéfini.

Voir également pauseMode() et resume().

void QWebSocket::setProxy(const QNetworkProxy &networkProxy)

Définit le proxy sur networkProxy

Voir aussi proxy().

void QWebSocket::setReadBufferSize(qint64 size)

Définit la taille du tampon de lecture interne de la fonction ` QWebSocket` à size octets.

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

Voir également readBufferSize().

void QWebSocket::setSslConfiguration(const QSslConfiguration &sslConfiguration)

Définit la configuration SSL du socket en utilisant le contenu du fichier sslConfiguration.

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

Voir également sslConfiguration().

QSslConfiguration QWebSocket::sslConfiguration() const

Renvoie l'état de la configuration SSL du socket. Par défaut, la configuration SSL d'un socket consiste à utiliser les algorithmes de chiffrement par défaut, les certificats CA par défaut, sans clé privée ni certificat local. La configuration SSL contient également des champs susceptibles d'évoluer au fil du temps sans préavis.

Voir également setSslConfiguration().

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

QWebSocket émet ce signal après la négociation SSL pour indiquer qu’une ou plusieurs erreurs se sont produites lors de la vérification de l’identité du pair. Ces erreurs indiquent généralement qu’ QWebSocket est incapable d’identifier le pair de manière sécurisée. À moins qu’une action ne soit entreprise, la connexion sera interrompue après l’émission de ce signal. Si vous souhaitez poursuivre la connexion malgré les erreurs survenues, vous devez appeler la fonction ` QWebSocket::ignoreSslErrors()` depuis un slot connecté à ce signal. Si vous avez besoin d’accéder à la liste des erreurs ultérieurement, vous pouvez appeler la fonction `sslErrors()` (sans argument).

errors contient une ou plusieurs erreurs qui empêchent QWebSocket de vérifier l’identité du pair.

QAbstractSocket::SocketState QWebSocket::state() const

Renvoie l'état actuel de la socket.

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

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

QAbstractSocket::SocketState n'est pas un métatype enregistré ; par conséquent, pour les connexions en file d'attente, vous devrez l'enregistrer à l'aide de 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. L’ frame contient les données et l’ isLastFrame indique s’il s’agit de la dernière trame du message complet.

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

Voir également binaryFrameReceived().

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

Ce signal est émis à chaque fois qu'un SMS est reçu. L'message contient le texte reçu.

Voir également binaryMessageReceived().

QWebSocketProtocol::Version QWebSocket::version() const

Renvoie la version actuellement utilisée par le socket.