Bluetooth Chat Example

Chat Server

The chat server is implemented by the ChatServer class. The ChatServer class is declared as:

 class ChatServer : public QObject
 {
     Q_OBJECT

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

     void startServer();
     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:
     QRfcommServer *rfcommServer;
     QBluetoothServiceInfo serviceInfo;
     QList<QBluetoothSocket *> clientSockets;
 };

The first thing the chat server needs to do is create an instance of QRfcommServer to listen for incoming Bluetooth connections. Our clientConnected() slot will be called whenever a new connection is created.

 rfcommServer = new QRfcommServer(this);
 connect(rfcommServer, SIGNAL(newConnection()), this, SLOT(clientConnected()));
 rfcommServer->listen();

The chat server is only useful if others know that it is there. To enable other devices to discover it a record describing the service needs to be published in the systems SDP (Service Discovery Protocol) database. The QBluetoothServiceInfo class encapsulates a service record.

We will publish a service record that contains some textural descriptions of the services, a UUID that uniquely identifies the service, the discoverability attribute and connection parameters.

The textural description of the service is stored in the ServiceName, ServiceDescription and ServiceProvider attributes.

 serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceName, tr("Bt Chat Server"));
 serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceDescription,
                          tr("Example bluetooth chat server"));
 serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceProvider, tr("Nokia, QtDF"));

Bluetooth uses UUIDs as unique identifiers. Our chat service is uses a randomly generated UUID.

 static const QLatin1String serviceUuid("e8e10f95-1a70-4b27-9ccf-02010264e9c8");
 serviceInfo.setServiceUuid(QBluetoothUuid(serviceUuid));

A Bluetooth service is only discoverable if it is in the PublicBrowseGroup.

 serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList,
                          QBluetoothUuid(QBluetoothUuid::PublicBrowseGroup));

The ProtocolDescriptorList attribute is used to publish the connection parameters that the remote device requires to connect to our service. Here we specify that the Rfcomm protocol is used and set the port number to port that our rfcommServer instance is listening to.

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

Finally we register the service record with the system.

 serviceInfo.registerService();

As mentioned earlier incoming connections are handled in the clientConnected() slot. In this slot we get a pointer a QBluetoothSocket representing the next pending connection connect up slots to the readyRead() and disconnected() signals and emit a signal to notify others that a new client has connected.

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

     connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
     connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
     clientSockets.append(socket);

     emit clientConnected(socket->peerName());
 }

The readSocket() slot is called whenever data is ready to be read from a client socket. The slot reads individual lines from the socket converts them from UTF-8 and emits the messageReceived() signal.

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

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

The clientDisconnected() slot is called whenever a client disconnects from the service. The slot emits a signal to notify others that a client has disconnected and deletes the socket.

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

     emit clientDisconnected(socket->peerName());

     clientSockets.removeOne(socket);

     socket->deleteLater();
 }

The sendMessage() slot is used to send a message to all connected clients. The message is converted into UTF-8 and appended with a newline before being sent to all clients.

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

     foreach (QBluetoothSocket *socket, clientSockets)
         socket->write(text);
 }

When the chat server is stop the service record is removed from the system SDP database, all connected client sockets are deleted and the QRfcommServer instance is deleted.

 void ChatServer::stopServer()
 {
     // Unregister service
     serviceInfo.unregisterService();

     // Close sockets
     qDeleteAll(clientSockets);

     // Close server
     delete rfcommServer;
     rfcommServer = 0;
 }

 class ChatClient : public QObject
 {
     Q_OBJECT

 public:
     explicit ChatClient(QObject *parent = 0);
     ~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();

 private slots:
     void readSocket();
     void connected();

 private:
     QBluetoothSocket *socket;
 };

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

     // Connect to service
     socket = new QBluetoothSocket(QBluetoothSocket::RfcommSocket);
     qDebug() << "Create socket";
     socket->connectToService(remoteService);
     qDebug() << "ConnecttoService done";

     connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
     connect(socket, SIGNAL(connected()), this, SLOT(connected()));
     connect(socket, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
 }

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

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

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

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

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

 class Chat : public QDialog
 {
     Q_OBJECT

 public:
     Chat(QWidget *parent = 0);
     ~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);

 private:
     Ui_Chat *ui;

     ChatServer *server;
     QList<ChatClient *> clients;

     QString localName;
 };

 ui->setupUi(this);

 #if defined (Q_OS_SYMBIAN) || defined(Q_OS_WINCE) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6)
 setWindowState(Qt::WindowFullScreen);
 #endif

 connect(ui->quitButton, SIGNAL(clicked()), this, SLOT(accept()));
 connect(ui->connectButton, SIGNAL(clicked()), this, SLOT(connectClicked()));
 connect(ui->sendButton, SIGNAL(clicked()), this, SLOT(sendClicked()));

 server = new ChatServer(this);
 connect(server, SIGNAL(clientConnected(QString)), this, SLOT(clientConnected(QString)));
 connect(server, SIGNAL(clientDisconnected(QString)), this, SLOT(clientDisconnected(QString)));
 connect(server, SIGNAL(messageReceived(QString,QString)),
         this, SLOT(showMessage(QString,QString)));
 connect(this, SIGNAL(sendMessage(QString)), server, SLOT(sendMessage(QString)));
 server->startServer();

 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));
 }

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

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

     // scan for services
     RemoteSelector remoteSelector;
     remoteSelector.startDiscovery(QBluetoothUuid(serviceUuid));
     if (remoteSelector.exec() == QDialog::Accepted) {
         QBluetoothServiceInfo service = remoteSelector.service();

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

         // Create client
         qDebug() << "Going to create client";
         ChatClient *client = new ChatClient(this);
 qDebug() << "Connecting...";

         connect(client, SIGNAL(messageReceived(QString,QString)),
                 this, SLOT(showMessage(QString,QString)));
         connect(client, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
         connect(client, SIGNAL(connected(QString)), this, SLOT(connected(QString)));
         connect(this, SIGNAL(sendMessage(QString)), client, SLOT(sendMessage(QString)));
 qDebug() << "Start client";
         client->startClient(service);

         clients.append(client);
     }

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

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

 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);
 }

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