En esta página

Chat por Bluetooth

Muestra la comunicación a través de Bluetooth utilizando el protocolo RFCOMM.

El ejemplo «Chat por Bluetooth» muestra cómo utilizar la Qt Bluetooth API para comunicarse con otra aplicación en un dispositivo remoto mediante el protocolo Bluetooth RFCOMM.

Interfaz de usuario de chat por Bluetooth en Qt Bluetooth

El ejemplo «Bluetooth Chat» implementa un sencillo programa de chat entre varios participantes. La aplicación actúa siempre como servidor y como cliente, lo que elimina la necesidad de determinar quién debe conectarse con quién.

Ejecución del ejemplo

Puedes ejecutar el ejemplo desde:

Servidor de chat

El servidor de chat se implementa mediante la clase ` ChatServer `. La clase ` ChatServer ` se declara de la siguiente manera:

class ChatServer : public QObject
{
    Q_OBJECT

public:
    explicit ChatServer(QObject *parent = nullptr);
    ~ChatServer();

    void startServer(const QBluetoothAddress &localAdapter = QBluetoothAddress());
    void stopServer();

public slots:
    void sendMessage(const QString &message);

signals:
    void messageReceived(const QString &sender, const QString &message);
    void clientConnected(const QString &name);
    void clientDisconnected(const QString &name);

private slots:
    void clientConnected();
    void clientDisconnected();
    void readSocket();

private:
    QBluetoothServer *rfcommServer = nullptr;
    QBluetoothServiceInfo serviceInfo;
    QList<QBluetoothSocket *> clientSockets;
    QMap<QBluetoothSocket *, QString> clientNames;
};

Lo primero que debe hacer el servidor de chat es crear una instancia de ` QBluetoothServer ` para escuchar las conexiones Bluetooth entrantes. El método ` clientConnected() ` se llamará cada vez que se establezca una nueva conexión.

rfcommServer = new QBluetoothServer(QBluetoothServiceInfo::RfcommProtocol, this);
connect(rfcommServer, &QBluetoothServer::newConnection,
        this, QOverload<>::of(&ChatServer::clientConnected));
bool result = rfcommServer->listen(localAdapter);
if (!result) {
    qWarning() << "Cannot bind chat server to" << localAdapter.toString();
   return;
}

El servidor de chat solo es útil si los demás saben que está ahí. Para que otros dispositivos puedan detectarlo, es necesario publicar un registro que describa el servicio en la base de datos SDP (Protocolo de Detección de Servicios) del sistema. La clase QBluetoothServiceInfo encapsula un registro de servicio.

Publicaremos un registro de servicio que contenga algunas descripciones textuales de los servicios, un UUID que identifique de forma única al servicio, el atributo de detectabilidad y los parámetros de conexión.

La descripción textual del servicio se almacena en los atributos ` ServiceName`, ` ServiceDescription` y ` ServiceProvider `.

serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceName, tr("Bt Chat Server"));
serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceDescription,
                         tr("Example bluetooth chat server"));
serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceProvider, tr("qt-project.org"));

Bluetooth utiliza UUID como identificadores únicos. El servicio de chat utiliza un UUID generado aleatoriamente.

static constexpr auto serviceUuid = "e8e10f95-1a70-4b27-9ccf-02010264e9c8"_L1;
serviceInfo.setServiceUuid(QBluetoothUuid(serviceUuid));

Un servicio Bluetooth solo es detectable si se encuentra en el modo de detección ( PublicBrowseGroup).

const auto groupUuid = QBluetoothUuid(QBluetoothUuid::ServiceClassUuid::PublicBrowseGroup);
QBluetoothServiceInfo::Sequence publicBrowse;
publicBrowse << QVariant::fromValue(groupUuid);
serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList, publicBrowse);

El atributo « ProtocolDescriptorList » se utiliza para publicar los parámetros de conexión que el dispositivo remoto necesita para conectarse a nuestro servicio. Aquí especificamos que se utiliza el protocolo Rfcomm y establecemos el número de puerto en aquel en el que está a la escucha nuestra instancia de rfcommServer.

QBluetoothServiceInfo::Sequence protocolDescriptorList;
QBluetoothServiceInfo::Sequence protocol;
protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::ProtocolUuid::L2cap));
protocolDescriptorList.append(QVariant::fromValue(protocol));
protocol.clear();
protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::ProtocolUuid::Rfcomm))
         << QVariant::fromValue(quint8(rfcommServer->serverPort()));
protocolDescriptorList.append(QVariant::fromValue(protocol));
serviceInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList,
                         protocolDescriptorList);

Por último, registramos el registro del servicio en el sistema.

serviceInfo.registerService(localAdapter);

Como se ha mencionado anteriormente, las conexiones entrantes se gestionan en el slot « clientConnected() », donde las conexiones pendientes se conectan a las señales « readyRead()» y « disconnected()». Estas señales notifican a los demás que se ha conectado un nuevo cliente.

void ChatServer::clientConnected()
{
    QBluetoothSocket *socket = rfcommServer->nextPendingConnection();
    if (!socket)
        return;

    connect(socket, &QBluetoothSocket::readyRead, this, &ChatServer::readSocket);
    connect(socket, &QBluetoothSocket::disconnected,
            this, QOverload<>::of(&ChatServer::clientDisconnected));
    clientSockets.append(socket);
    clientNames[socket] = socket->peerName();
    emit clientConnected(socket->peerName());
}

La ranura readSocket() se activa cada vez que hay datos listos para ser leídos desde un socket de cliente. La ranura lee líneas individuales del socket, las convierte desde UTF-8 y emite la señal messageReceived().

void ChatServer::readSocket()
{
    QBluetoothSocket *socket = qobject_cast<QBluetoothSocket *>(sender());
    if (!socket)
        return;

    while (socket->canReadLine()) {
        QByteArray line = socket->readLine().trimmed();
        emit messageReceived(clientNames[socket],
                             QString::fromUtf8(line.constData(), line.length()));
    }
}

La ranura « clientDisconnected() » se activa cada vez que un cliente se desconecta del servicio. La ranura emite una señal para notificar a los demás que un cliente se ha desconectado y elimina el socket.

void ChatServer::clientDisconnected()
{
    QBluetoothSocket *socket = qobject_cast<QBluetoothSocket *>(sender());
    if (!socket)
        return;

    emit clientDisconnected(clientNames[socket]);

    clientSockets.removeOne(socket);
    clientNames.remove(socket);

    socket->deleteLater();
}

La ranura « sendMessage() » se utiliza para enviar un mensaje a todos los clientes conectados. El mensaje se convierte a UTF-8 y se le añade un salto de línea antes de enviarse a todos los clientes.

void ChatServer::sendMessage(const QString &message)
{
    QByteArray text = message.toUtf8() + '\n';

    for (QBluetoothSocket *socket : std::as_const(clientSockets))
        socket->write(text);
}

Cuando se detiene el servidor de chat, el registro del servicio se elimina de la base de datos SDP del sistema, se eliminan todos los sockets de los clientes conectados y se elimina la instancia de « rfcommServer ».

void ChatServer::stopServer()
{
    // Dar de baja el servicio
    serviceInfo.unregisterService();

    // Cerrar sockets
    qDeleteAll(clientSockets);
    clientNames.clear();

    // Cerrar el servidor
    delete rfcommServer;
    rfcommServer = nullptr;
}

Detección de servicios

Antes de conectarse al servidor, el cliente debe escanear los dispositivos cercanos y buscar aquel que esté anunciando el servicio de chat. De ello se encarga la clase RemoteSelector.

Para iniciar la búsqueda del servicio, RemoteSelector crea una instancia de QBluetoothServiceDiscoveryAgent y se conecta a sus señales.

    m_discoveryAgent = new QBluetoothServiceDiscoveryAgent(localAdapter);

    connect(m_discoveryAgent, &QBluetoothServiceDiscoveryAgent::serviceDiscovered,
            this, &RemoteSelector::serviceDiscovered);
    connect(m_discoveryAgent, &QBluetoothServiceDiscoveryAgent::finished,
            this, &RemoteSelector::discoveryFinished);
    connect(m_discoveryAgent, &QBluetoothServiceDiscoveryAgent::canceled,
            this, &RemoteSelector::discoveryFinished);

Se configura un filtro UUID para que la búsqueda de servicios solo muestre los dispositivos que anuncian el servicio necesario. A continuación, se inicia un ` FullDiscovery `:

    m_discoveryAgent->setUuidFilter(uuid);
    m_discoveryAgent->start(QBluetoothServiceDiscoveryAgent::FullDiscovery);

Cuando se descubre un servicio que coincide, se emite una señal ` serviceDiscovered()` con una instancia de ` QBluetoothServiceInfo ` como parámetro. Esta información del servicio se utiliza para extraer el nombre del dispositivo y el nombre del servicio, y añadir una nueva entrada a la lista de dispositivos remotos descubiertos:

    QString remoteName;
    if (serviceInfo.device().name().isEmpty())
        remoteName = address.toString();
    else
        remoteName = serviceInfo.device().name();

    QListWidgetItem *item =
        new QListWidgetItem(QString::fromLatin1("%1 %2").arg(remoteName,
                                                             serviceInfo.serviceName()));

    m_discoveredServices.insert(item, serviceInfo);
    ui->remoteDevices->addItem(item);

Posteriormente, el usuario puede seleccionar uno de los dispositivos de la lista e intentar conectarse a él.

Cliente de chat

El cliente de chat está implementado por la clase ` ChatClient `. La clase ` ChatClient ` se declara así:

class ChatClient : public QObject
{
    Q_OBJECT

public:
    explicit ChatClient(QObject *parent = nullptr);
    ~ChatClient();

    void startClient(const QBluetoothServiceInfo &remoteService);
    void stopClient();

public slots:
    void sendMessage(const QString &message);

signals:
    void messageReceived(const QString &sender, const QString &message);
    void connected(const QString &name);
    void disconnected();
    void socketErrorOccurred(const QString &errorString);

private slots:
    void readSocket();
    void connected();
    void onSocketErrorOccurred(QBluetoothSocket::SocketError);

private:
    QBluetoothSocket *socket = nullptr;
};

El cliente crea un nuevo objeto ` QBluetoothSocket ` y se conecta al servicio remoto descrito por el parámetro ` remoteService `. Las ranuras están conectadas a las señales ` readyRead()`, ` connected()` y ` disconnected()` del socket.

void ChatClient::startClient(const QBluetoothServiceInfo&remoteService)
{
    if (socket)
        return;

    // Conexión al servicio
    socket = new QBluetoothSocket(QBluetoothServiceInfo::RfcommProtocol);
    qDebug() << "Create socket";
    socket->connectToService(remoteService);
    qDebug() << "ConnectToService done";

    connect(socket, &QBluetoothSocket::readyRead, this, &ChatClient::readSocket);
    connect(socket, &QBluetoothSocket::connected, this, QOverload<>::of(&ChatClient::connected));
    connect(socket, &QBluetoothSocket::disconnected, this, &ChatClient::disconnected);
    connect(socket, &QBluetoothSocket::errorOccurred, this, &ChatClient::onSocketErrorOccurred);
}

Cuando la conexión del socket se establece correctamente, emitimos una señal para notificarlo a los demás usuarios.

void ChatClient::connected()
{
    emit connected(socket->peerName());
}

Al igual que en el servidor de chat, se invoca la ranura readSocket() cuando hay datos disponibles en el socket. Las líneas se leen una a una y se convierten desde UTF-8. Se emite la señal messageReceived().

void ChatClient::readSocket()
{
    if (!socket)
        return;

    while (socket->canReadLine()) {
        QByteArray line = socket->readLine().trimmed();
        emit messageReceived(socket->peerName(),
                             QString::fromUtf8(line.constData(), line.length()));
    }
}

La ranura sendMessage() se utiliza para enviar un mensaje al dispositivo remoto. El mensaje se convierte a UTF-8 y se le añade un salto de línea.

void ChatClient::sendMessage(const QString &message)
{
    QByteArray text = message.toUtf8() + '\n';
    socket->write(text);
}

Para desconectarse del servicio de chat remoto, se elimina la instancia de ` QBluetoothSocket `.

void ChatClient::stopClient()
{
    delete socket;
    socket = nullptr;
}

Cuadro de diálogo de chat

La ventana principal de este ejemplo es el cuadro de diálogo de chat, implementado en la clase ` Chat `. Esta clase muestra una sesión de chat entre un único ` ChatServer ` y cero o más ` ChatClient`s. La clase ` Chat ` se declara así:

class Chat : public QDialog
{
    Q_OBJECT

public:
    explicit Chat(QWidget *parent = nullptr);
    ~Chat();

signals:
    void sendMessage(const QString &message);

private slots:
    void connectClicked();
    void sendClicked();

    void showMessage(const QString &sender, const QString &message);

    void clientConnected(const QString &name);
    void clientDisconnected(const QString &name);
    void clientDisconnected();
    void connected(const QString &name);
    void reactOnSocketError(const QString &error);

    void newAdapterSelected();

    void initBluetooth();

    void updateIcons(Qt::ColorScheme scheme);

private:
    int adapterFromUserSelection() const;
    int currentAdapterIndex = 0;
    Ui::Chat *ui;

    ChatServer *server = nullptr;
    QList<ChatClient *> clients;
    QList<QBluetoothHostInfo> localAdapters;

    QString localName;
};

En primer lugar, creamos la interfaz de usuario

ui->setupUi(this);

connect(ui->connectButton, &QPushButton::clicked, this, &Chat::connectClicked);
connect(ui->sendButton, &QPushButton::clicked, this, &Chat::sendClicked);

Creamos una instancia de ` ChatServer ` y respondemos a sus señales ` clientConnected()`, ` clientDiconnected()` y ` messageReceived() `.

server = new ChatServer(this);
connect(server, QOverload<const QString &>::of(&ChatServer::clientConnected),
        this, &Chat::clientConnected);
connect(server, QOverload<const QString &>::of(&ChatServer::clientDisconnected),
        this,  QOverload<const QString &>::of(&Chat::clientDisconnected));
connect(server, &ChatServer::messageReceived,
        this,  &Chat::showMessage);
connect(this, &Chat::sendMessage, server, &ChatServer::sendMessage);
server->startServer();

En respuesta a las señales « clientConnected() » y « clientDisconnected() » de « ChatServer », mostramos los mensajes típicos «X se ha unido al chat» y «Y se ha ido» en la sesión de chat.

void Chat::clientConnected(const QString &name)
{
    ui->chat->insertPlainText(QString::fromLatin1("%1 has joined chat.\n").arg(name));
}

void Chat::clientDisconnected(const QString &name)
{
    ui->chat->insertPlainText(QString::fromLatin1("%1 has left.\n").arg(name));
}

Los mensajes entrantes procedentes de clientes conectados a ChatServer se gestionan en la ranura showMessage(). El texto del mensaje, etiquetado con el nombre del dispositivo remoto, se muestra en la sesión de chat.

void Chat::showMessage(const QString &sender, const QString &message)
{
    ui->chat->moveCursor(QTextCursor::End);
    ui->chat->insertPlainText(QString::fromLatin1("%1: %2\n").arg(sender, message));
    ui->chat->ensureCursorVisible();
}

Al hacer clic en el botón «Conectar», la aplicación inicia la búsqueda de servicios y muestra una lista de los servicios de chat detectados en los dispositivos remotos. El usuario selecciona un ChatClient para el servicio.

void Chat::connectClicked()
{
    ui->connectButton->setEnabled(false);

    // buscar servicios
    const QBluetoothAddress adaptador = localAdapters.isEmpty() ?
                                           QBluetoothAddress() :
                                           localAdapters.at(currentAdapterIndex).address();

    RemoteSelector remoteSelector(adapter);
#ifdef Q_OS_ANDROID
    // QTBUG-61392
    Q_UNUSED(serviceUuid);
    remoteSelector.startDiscovery(QBluetoothUuid(reverseUuid));
#else
    remoteSelector.startDiscovery(QBluetoothUuid(serviceUuid));
#endif
    if (remoteSelector.exec()== QDialog::Accepted) {
        QBluetoothServiceInfo service = remoteSelector.service();

        qDebug() << "Connecting to service" << service.serviceName()
                << "on" << service.device().name();

        // Crear cliente
        ChatClient *client = new ChatClient(this);

        connect(client, &ChatClient::messageReceived,
                this, &Chat::showMessage);
        connect(client, &ChatClient::disconnected,
                this, QOverload<>::of(&Chat::clientDisconnected));
        connect(client, QOverload<const QString&>::of(&ChatClient::connected),
                this, &Chat::connected);
        connect(client, &ChatClient::socketErrorOccurred,
                this, &Chat::reactOnSocketError);
        connect(this, &Chat::sendMessage, client, &ChatClient::sendMessage);
        client->startClient(service);

        clients.append(client);
    }

    ui->connectButton->setEnabled(true);
}

En respuesta a las señales « connected() » procedentes de ChatClient, mostramos el mensaje «Se ha unido al chat X.» en la sesión de chat.

void Chat::connected(const QString &name)
{
    ui->chat->insertPlainText(QString::fromLatin1("Joined chat with %1.\n").arg(name));
}

Los mensajes se envían a todos los dispositivos remotos a través de las instancias de ` ChatServer ` y ` ChatClient ` mediante la emisión de la señal ` sendMessage() `.

void Chat::sendClicked()
{
    ui->sendButton->setEnabled(false);
    ui->sendText->setEnabled(false);

    showMessage(localName, ui->sendText->text());
    emit sendMessage(ui->sendText->text());

    ui->sendText->clear();

    ui->sendText->setEnabled(true);
    ui->sendButton->setEnabled(true);
#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
    // avoid keyboard automatically popping up again on mobile devices
    ui->sendButton->setFocus();
#else
    ui->sendText->setFocus();
#endif
}

Debemos limpiar las instancias de ChatClient cuando el dispositivo remoto fuerza una desconexión.

void Chat::clientDisconnected()
{
    ChatClient *client = qobject_cast<ChatClient *>(sender());
    if (client) {
        clients.removeOne(client);
        client->deleteLater();
    }
}

Proyecto de ejemplo en @code.qt.io

© 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.