Sur cette page

QBluetoothSocket Class

La classe QBluetoothSocket permet de se connecter à un périphérique Bluetooth utilisant un serveur Bluetooth. Plus d'informations...

En-tête : #include <QBluetoothSocket>
CMake : find_package(Qt6 REQUIRED COMPONENTS Bluetooth)
target_link_libraries(mytarget PRIVATE Qt6::Bluetooth)
qmake : QT += bluetooth
Héritages : QIODevice

Types publics

enum class SocketError { UnknownSocketError, NoSocketError, HostNotFoundError, ServiceNotFoundError, NetworkError, …, MissingPermissionsError }
enum class SocketState { UnconnectedState, ServiceLookupState, ConnectingState, ConnectedState, BoundState, …, ListeningState }

Fonctions publiques

QBluetoothSocket(QObject *parent = nullptr)
QBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, QObject *parent = nullptr)
virtual ~QBluetoothSocket()
void abort()
void connectToService(const QBluetoothServiceInfo &service, QIODeviceBase::OpenMode openMode = ReadWrite)
void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid, QIODeviceBase::OpenMode openMode = ReadWrite)
void connectToService(const QBluetoothAddress &address, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite)
void disconnectFromService()
QBluetoothSocket::SocketError error() const
QString errorString() const
QBluetoothAddress localAddress() const
QString localName() const
quint16 localPort() const
QBluetoothAddress peerAddress() const
QString peerName() const
quint16 peerPort() const
QBluetooth::SecurityFlags preferredSecurityFlags() const
void setPreferredSecurityFlags(QBluetooth::SecurityFlags flags)
bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType, QBluetoothSocket::SocketState socketState = SocketState::ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)
int socketDescriptor() const
QBluetoothServiceInfo::Protocol socketType() const
QBluetoothSocket::SocketState state() const

Fonctions publiques réimplémentées

virtual qint64 bytesAvailable() const override
virtual qint64 bytesToWrite() const override
virtual bool canReadLine() const override
virtual void close() override
virtual bool isSequential() const override

Signaux

void connected()
void disconnected()
(since 6.2) void errorOccurred(QBluetoothSocket::SocketError error)
void stateChanged(QBluetoothSocket::SocketState state)

Fonctions protégées

void doDeviceDiscovery(const QBluetoothServiceInfo &service, QIODeviceBase::OpenMode openMode)
void setSocketError(QBluetoothSocket::SocketError error_)
void setSocketState(QBluetoothSocket::SocketState state)

Fonctions protégées réimplémentées

virtual qint64 readData(char *data, qint64 maxSize) override
virtual qint64 writeData(const char *data, qint64 maxSize) override

Description détaillée

QBluetoothSocket supporte deux types de socket, L2CAP et RFCOMM.

L2CAP QBluetoothSocket est une socket Bluetooth de bas niveau orientée vers les datagrammes. Android ne prend pas en charge L2CAP pour les connexions de socket.

RFCOMM est une socket fiable, orientée flux. Les sockets RFCOMM émulent un port série RS-232.

Pour créer une connexion à un service Bluetooth, créez une socket du type approprié et appelez connectToService() en transmettant l'adresse et le numéro de port Bluetooth. QBluetoothSocket émet le signal connected() lorsque la connexion est établie.

Si Protocol n'est pas supporté sur une plateforme, l'appel à connectToService() émettra une erreur UnsupportedProtocolError.

Remarque : QBluetoothSocket ne prend pas en charge les opérations de lecture et d'écriture synchrones. Les fonctions telles que waitForReadyRead() et waitForBytesWritten() ne sont pas implémentées. Les opérations d'E/S doivent être effectuées à l'aide de readyRead(), read() et write().

Sur iOS, cette classe ne peut pas être utilisée car la plateforme n'expose pas d'API qui pourrait permettre l'accès aux fonctionnalités liées à QBluetoothSocket.

Note : Sur macOS Monterey (12), le flux de données de la socket est interrompu lorsqu'un dialogue modal est exécuté, ou qu'un mode de suivi d'événement est entré (par exemple en appuyant longuement sur le bouton de fermeture d'une fenêtre). Ce problème a été corrigé dans macOS Sequoia (15).

Documentation sur les types de membres

enum class QBluetoothSocket::SocketError

Cette énumération décrit les types d'erreurs des sockets Bluetooth.

ConstanteValeurDescription de l'erreur
QBluetoothSocket::SocketError::UnknownSocketError1Une erreur inconnue s'est produite.
QBluetoothSocket::SocketError::NoSocketError0Pas d'erreur. Utilisé pour les tests.
QBluetoothSocket::SocketError::HostNotFoundError3Impossible de trouver l'hôte distant.
QBluetoothSocket::SocketError::ServiceNotFoundError4Impossible de trouver l'UUID du service sur l'hôte distant.
QBluetoothSocket::SocketError::NetworkError5Une tentative de lecture ou d'écriture à partir d'une socket a retourné une erreur
QBluetoothSocket::SocketError::UnsupportedProtocolError6Le site Protocol n'est pas supporté sur cette plateforme.
QBluetoothSocket::SocketError::OperationError7Une opération a été tentée alors que la socket était dans un état qui ne le permettait pas.
QBluetoothSocket::SocketError::RemoteHostClosedError (since Qt 5.10)2L'hôte distant a fermé la connexion.
QBluetoothSocket::SocketError::MissingPermissionsError (since Qt 6.4)8Le système d'exploitation demande des autorisations qui n'ont pas été accordées par l'utilisateur.

enum class QBluetoothSocket::SocketState

Cette énumération décrit l'état de la socket Bluetooth.

ConstanteValeurDescription de l'état
QBluetoothSocket::SocketState::UnconnectedState0La socket n'est pas connectée.
QBluetoothSocket::SocketState::ServiceLookupState1La socket interroge les paramètres de connexion.
QBluetoothSocket::SocketState::ConnectingState2La socket tente de se connecter à un périphérique.
QBluetoothSocket::SocketState::ConnectedState3La socket est connectée à un périphérique.
QBluetoothSocket::SocketState::BoundState4La socket est liée à une adresse et à un port locaux.
QBluetoothSocket::SocketState::ClosingState5La socket est connectée et sera fermée une fois que toutes les données en attente auront été écrites sur la socket.
QBluetoothSocket::SocketState::ListeningState6La socket est à l'écoute des connexions entrantes.

Documentation des fonctions membres

[explicit] QBluetoothSocket::QBluetoothSocket(QObject *parent = nullptr)

Construit une prise Bluetooth avec parent.

[explicit] QBluetoothSocket::QBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, QObject *parent = nullptr)

Construit une prise Bluetooth de type socketType, avec parent.

[virtual noexcept] QBluetoothSocket::~QBluetoothSocket()

Détruit la prise Bluetooth.

void QBluetoothSocket::abort()

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

Remarque : sur Android, l'abandon de la socket nécessite une interaction asynchrone avec les threads Android. Par conséquent, les signaux disconnected() et stateChanged() associés sont retardés jusqu'à ce que les threads aient terminé la fermeture.

Voir également disconnectFromService() et close().

[override virtual] qint64 QBluetoothSocket::bytesAvailable() const

Réimplémente : QIODevice::bytesAvailable() const.

Renvoie le nombre d'octets entrants en attente de lecture.

Voir aussi bytesToWrite() et read().

[override virtual] qint64 QBluetoothSocket::bytesToWrite() const

Réimplémente : QIODevice::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.

[override virtual] bool QBluetoothSocket::canReadLine() const

Réimplémente : QIODevice::canReadLine() const.

Retourne vrai si vous pouvez lire au moins une ligne sur le périphérique

[override virtual] void QBluetoothSocket::close()

Réimplémente : QIODevice::close().

Déconnecte la connexion de la socket avec l'appareil.

Remarque : sur Android, la fermeture de la socket nécessite une interaction asynchrone avec les threads Android. Par conséquent, les signaux disconnected() et stateChanged() associés sont retardés jusqu'à ce que les threads aient terminé la fermeture.

void QBluetoothSocket::connectToService(const QBluetoothServiceInfo &service, QIODeviceBase::OpenMode openMode = ReadWrite)

Tente de se connecter au service décrit par service.

Le socket est ouvert dans l'adresse openMode. Le socketType() est ignoré si le service spécifie un QBluetoothServiceInfo::socketProtocol() différent.

La socket entre d'abord dans ConnectingState et tente de se connecter au périphérique fournissant service. Si une connexion est établie, QBluetoothSocket entre dans ConnectedState et émet connected().

À tout moment, la socket peut émettre errorOccurred() pour signaler qu'une erreur s'est produite.

Notez que la plupart des plateformes exigent un appairage avant de se connecter à l'appareil distant. Dans le cas contraire, le processus de connexion peut échouer.

Sur Android, seules les connexions RFCOMM sont possibles. Cette fonction ignore tout indicateur de protocole de socket et suppose qu'il s'agit de RFCOMM.

Voir aussi state() et disconnectFromService().

void QBluetoothSocket::connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid, QIODeviceBase::OpenMode openMode = ReadWrite)

Tente d'établir une connexion avec le service identifié par uuid sur le périphérique dont l'adresse est address.

Le socket est ouvert dans l'adresse openMode.

Pour BlueZ, le socket entre d'abord dans ServiceLookupState et demande les paramètres de connexion pour uuid. Si les paramètres de service sont récupérés avec succès, le socket entre dans ConnectingState et tente de se connecter à address. Si une connexion est établie, QBluetoothSocket entre dans ConnectedState et émet connected().

Sur Android, la connexion au service peut être établie directement en utilisant l'UUID du service distant. Par conséquent, la plateforme n'a pas besoin de ServiceLookupState et socketType() est toujours défini sur QBluetoothServiceInfo::RfcommProtocol.

À tout moment, le socket peut émettre errorOccurred() pour signaler qu'une erreur s'est produite.

Notez que la plupart des plateformes exigent un appairage avant de se connecter à l'appareil distant. Dans le cas contraire, le processus de connexion peut échouer.

Voir également state() et disconnectFromService().

void QBluetoothSocket::connectToService(const QBluetoothAddress &address, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite)

Tente d'établir une connexion avec address sur le site port.

La socket est ouverte dans l'adresse openMode.

La socket entre d'abord dans ConnectingState et tente de se connecter à address. Si une connexion est établie, QBluetoothSocket entre dans ConnectedState et émet connected().

À tout moment, le socket peut émettre errorOccurred() pour signaler qu'une erreur s'est produite.

Sur Android et BlueZ (version 5.46 ou supérieure), une connexion à un service ne peut pas être établie en utilisant un port. L'appel de cette fonction émettra un message ServiceNotFoundError.

Notez que la plupart des plateformes exigent un appairage avant de se connecter à l'appareil distant. Dans le cas contraire, le processus de connexion risque d'échouer.

Voir également state() et disconnectFromService().

[signal] void QBluetoothSocket::connected()

Ce signal est émis lorsqu'une connexion est établie.

Voir aussi QBluetoothSocket::SocketState::ConnectedState et stateChanged().

void QBluetoothSocket::disconnectFromService()

Tente de fermer le socket. S'il y a des données en attente d'écriture, QBluetoothSocket entrera dans ClosingState et attendra que toutes les données aient été écrites. Finalement, il entrera dans UnconnectedState et émettra le signal disconnected().

Voir aussi connectToService().

[signal] void QBluetoothSocket::disconnected()

Ce signal est émis lorsque la prise est déconnectée.

Voir aussi QBluetoothSocket::SocketState::UnconnectedState et stateChanged().

[protected] void QBluetoothSocket::doDeviceDiscovery(const QBluetoothServiceInfo &service, QIODeviceBase::OpenMode openMode)

Lancez la recherche de périphériques pour service et ouvrez le socket avec openMode. Si le socket est créé avec une adresse de périphérique uuid de service, utilisez la recherche de services pour trouver le numéro de port auquel se connecter.

QBluetoothSocket::SocketError QBluetoothSocket::error() const

Renvoie la dernière erreur.

[signal, since 6.2] void QBluetoothSocket::errorOccurred(QBluetoothSocket::SocketError error)

Ce signal est émis lorsqu'un error se produit.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi error().

QString QBluetoothSocket::errorString() const

Renvoie une chaîne de texte affichable par l'utilisateur pour l'erreur.

[override virtual] bool QBluetoothSocket::isSequential() const

Réimplémente : QIODevice::isSequential() const.

QBluetoothAddress QBluetoothSocket::localAddress() const

Renvoie l'adresse du périphérique local.

Bien que certaines plates-formes puissent différer, le socket doit généralement être connecté pour garantir le retour d'une adresse valide. Ceci est particulièrement vrai lorsqu'il s'agit de plates-formes qui supportent plusieurs adaptateurs Bluetooth locaux.

QString QBluetoothSocket::localName() const

Renvoie le nom du périphérique local.

Bien que certaines plates-formes puissent différer, le socket doit généralement être connecté pour garantir le retour d'un nom valide. C'est notamment le cas lorsqu'il s'agit de plateformes qui prennent en charge plusieurs adaptateurs Bluetooth locaux.

quint16 QBluetoothSocket::localPort() const

Renvoie le numéro de port du socket local s'il est disponible, sinon renvoie 0. Bien que certaines plateformes puissent différer, le socket doit généralement être connecté pour garantir le retour d'un numéro de port valide.

Sur Android et macOS, cette fonctionnalité n'est pas supportée et renvoie 0.

QBluetoothAddress QBluetoothSocket::peerAddress() const

Renvoie l'adresse de l'appareil homologue.

QString QBluetoothSocket::peerName() const

Renvoie le nom de l'appareil homologue.

quint16 QBluetoothSocket::peerPort() const

Renvoie le numéro de port de la socket homologue s'il est disponible, sinon renvoie 0. Sur Android, cette fonctionnalité n'est pas supportée.

QBluetooth::SecurityFlags QBluetoothSocket::preferredSecurityFlags() const

Renvoie les paramètres de sécurité utilisés pour la première tentative de connexion.

Les paramètres de sécurité peuvent être renégociés entre les deux parties pendant ou après l'établissement de la connexion. Si un tel changement se produit, il n'est pas reflété dans la valeur de cet indicateur.

Sous macOS, cet indicateur a toujours la valeur QBluetooth::Security::Secure.

Voir également setPreferredSecurityFlags().

[override virtual protected] qint64 QBluetoothSocket::readData(char *data, qint64 maxSize)

Réimplémente : QIODevice::readData(char *data, qint64 maxSize).

void QBluetoothSocket::setPreferredSecurityFlags(QBluetooth::SecurityFlags flags)

Définit le paramètre de sécurité préféré pour la tentative de connexion à flags. Cette valeur est incorporée lors de l'appel à connectToService(). Il est donc nécessaire de se reconnecter pour modifier ce paramètre pour une connexion existante.

Sur Bluez, cette propriété est définie par défaut sur QBluetooth::Security::Authorization.

Sur macOS, cette valeur est ignorée car la plateforme ne permet pas d'accéder au paramètre de sécurité de la socket. Par défaut, la plateforme préfère les connexions sécurisées/chiffrées et cette fonction renvoie donc toujours QBluetooth::Security::Secure.

Android ne supporte que deux niveaux de sécurité (sécurisé et non sécurisé). Si ce drapeau est défini sur QBluetooth::Security::NoSecurity, l'objet socket n'utilisera pas d'authentification ou de cryptage. Toute autre combinaison d'indicateur de sécurité déclenchera une connexion Bluetooth sécurisée. Cet indicateur est fixé à QBluetooth::Security::Secure par défaut.

Remarque : une connexion sécurisée nécessite un couplage entre les deux appareils. Sur certaines plateformes, l'appairage est automatiquement lancé lors de l'établissement de la connexion. Sur d'autres plateformes, l'application doit déclencher manuellement l'appairage avant de tenter de se connecter.

Voir aussi preferredSecurityFlags().

bool QBluetoothSocket::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType, QBluetoothSocket::SocketState socketState = SocketState::ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)

Définit la socket pour utiliser socketDescriptor avec un type de socketType, qui est dans l'état socketState, et le mode openMode.

Le descripteur de socket appartient à l'instance QBluetoothSocket et peut être fermé une fois l'opération terminée.

Retourne true en cas de succès.

Voir aussi socketDescriptor().

[protected] void QBluetoothSocket::setSocketError(QBluetoothSocket::SocketError error_)

Définit le type d'erreur qui s'est produit en dernier lieu à error_.

[protected] void QBluetoothSocket::setSocketState(QBluetoothSocket::SocketState state)

Définit l'état de la socket à state.

int QBluetoothSocket::socketDescriptor() const

Renvoie le descripteur de socket spécifique à la plate-forme, s'il est disponible. Cette fonction renvoie -1 si le descripteur n'est pas disponible ou si une erreur s'est produite.

Voir aussi setSocketDescriptor().

QBluetoothServiceInfo::Protocol QBluetoothSocket::socketType() const

Renvoie le type de socket. La socket s'adapte automatiquement au protocole proposé par le service distant.

Android ne prend en charge que les sockets basées sur RFCOMM.

QBluetoothSocket::SocketState QBluetoothSocket::state() const

Renvoie l'état actuel de la socket.

[signal] void QBluetoothSocket::stateChanged(QBluetoothSocket::SocketState state)

Ce signal est émis lorsque l'état de la socket passe à state.

Voir aussi connected(), disconnected(), state(), et QBluetoothSocket::SocketState.

[override virtual protected] qint64 QBluetoothSocket::writeData(const char *data, qint64 maxSize)

Réimplémente : QIODevice::writeData(const char *data, qint64 maxSize).

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.