Pull to refresh

Разработка для Sailfish OS: Работа с Bluetooth

Development of mobile applicationsQtDevelopment for Sailfish OS
Tutorial
Здравствуйте! Данная статья является продолжением цикла статей, посвященных разработке для мобильной платформы Sailfish OS. На этот раз речь пойдёт об использовании Bluetooth для установки соединения между двумя устройствами и передачи данных.

Bluetooth


Технология Bluetooth позволяет создавать беспроводное соединение, благодаря которому возможна передача абсолютно любых данных. Существует целый ряд задач для которых Bluetooth является общепринятым решением, например, передача файлов с одного устройства на другое, подключение к Bluetooth гарнитурам или дистанционное управление сканерами и принтерами.

Приложение-пример


Будем рассматривать использование технологии Bluetooth на примере реализации приложения для обмена строками. Назовём его bluetooth-messenger. Приложение будет работать в двух режимах: сервер и клиент. Сервер будет регистрировать Bluetooth сервис и реагировать на подключение клиента. Клиент же будет искать созданный сервис, подключаться к нему и передавать данные. Как следствие, необходимо наличие двух устройств, работающих под управлением Sailfish OS.

В итоге приложение будет работать следующим образом:

  1. Клиент ищет сервер с зарегистрированным сервисом.
  2. Найденному серверу передаёт строку.
  3. Сервер принимает строку, отображает её на экране.
  4. Принятая строка разворачивается и передаётся обратно клиенту.
  5. Клиент отображает развёрнутую строку на экране и отключается от сервера.


Реализация данного приложения позволит полностью осветить необходимые инструменты для установки связи между двумя устройствами и обмена данными между ними.

Предоставление повышенных привилегий приложению


Для взаимодействия с Bluetooth приложению иногда требуются повышенные привилегии (для поиска сервисов, изменения настроек видимости, для сопряжения устройств). При отсутствии повышенных привилегий часть функционала будет недоступна, поэтому рекомендуем выдавать их приложению, работающему с Bluetooth.

Для отладки необходимо запускать приложение с помощью devel-su с флагом -p. Это позволяет запускать приложение с повышенными привилегиями, а отладочный вывод будет доступен в консоли.

devel-su -p /usr/bin/bluetooth-messenger

Для того, чтобы запустить приложение с повышенными привилегиями по нажатию на иконку, необходимо сделать некоторые настройки в исходных файлах проекта. Во-первых, исполняемый файл приложения нужно запускать с помощью invoker. Invoker находит главную функцию приложения и запускает её с переданными ему аргументами. Это настраивается в .desktop файле проекта следующей строчкой:

Exec=invoker --type=silica-qt5 -s /usr/bin/bluetooth-messenger

Во-вторых, необходимо создать файл с названием, соответствующим названию исполняемого файла, в директории /usr/share/mapplauncherd/privileges.d/ и поместить туда строчку:

/usr/bin/bluetooth-messenger,

Запятая в конце строчки обязательно нужна. Таким образом при нажатии на иконку приложения, пользователь запустит его с повышенными привилегиями.

Управление состоянием Bluetooth


Для начала необходимо понять, каким образом возможно управлять состоянием Bluetooth. Для этого следует использовать систему D-Bus, взаимодействие с которой было описано в одной из предыдущих статей. С помощью данной системы мы имеем возможность включать и выключать питание Bluetooth и настраивать видимость для других устройств.

Для включения Bluetooth необходимо использовать сервис net.connman. На интерфейсе net.connman по пути /net/connman/technology/bluetooth есть метод SetProperty, с помощью которого возможно установить значение свойства Powered, которое отвечает за то включен Bluetooth или нет. Устанавливается свойство следующим образом:

QDBusInterface bluetoothInterface("net.connman", "/net/connman/technology/bluetooth",
  "net.connman.Technology", QDBusConnection::systemBus(), this);
bluetoothInterface.call("SetProperty", "Powered", QVariant::fromValue(QDBusVariant(true)));

Создаём экземпляр QDBusInterface с использованием перечисленных ранее сервиса, пути и интерфейса. Затем на интерфейсе вызываем метод SetProperty с двумя аргументами: названием свойства и значением.

После включения Bluetooth будет полезно настроить видимость для других устройств. Для этого используем сервис org.bluez. Во-первых необходимо получить путь, соответствующий текущему устройству. Для этого по корневому пути на интерфейсе org.bluez.Manager вызываем метод DefaultAdapter, содержащий в выходных аргументах путь к текущему адаптеру, который впоследствии мы будем использовать для установки видимости.

QDBusInterface adapterListInterface("org.bluez", "/", "org.bluez.Manager",
  QDBusConnection::systemBus(), this);
QVariant adapterPath = adapterListInterface.call("DefaultAdapter").arguments().at(0);

После получения пути для установки видимости необходимо использовать метод SetProperty на интерфейсе org.bluez.Adapter для установки следующих свойств:

  • DiscoverableTimeout – время в секундах (unsigned int), в течении которого устройство будет возможно обнаружить после включения обнаружения. Если установлено значение 0, то обнаружение запускается без таймера.
  • Discoverable – в зависимости от значения true или false включает или выключает обнаружение.

Неограниченное по времени обнаружение включаем следующими строчками:

QDBusInterface bluetoothAdapter("org.bluez", adapterPath.value<QDBusObjectPath>().path(),
  "org.bluez.Adapter", QDBusConnection::systemBus(), this);
bluetoothAdapter.call("SetProperty", "DiscoverableTimeout", QVariant::fromValue(QDBusVariant(0U)));
bluetoothAdapter.call("SetProperty", "Discoverable", QVariant::fromValue(QDBusVariant(true)));

Следует заметить, что для настройки опций видимости необходимо, чтобы приложение было запущено с повышенными привилегиями.

Регистрация сервиса Bluetooth


Для начала нам необходимо создать сервер и зарегистрировать на нём сервис. Данный сервис будет принимать сообщения от клиентов и отвечать им. Для решения данной задачи мы создадим класс MessengerServer, заголовочный файл которого будет содержать следующее:

class MessengerServer : public QObject {
  Q_OBJECT
public:
  explicit MessengerServer(QObject *parent = 0);
  ~MessengerServer();
  Q_INVOKABLE void startServer();
  Q_INVOKABLE void stopServer();

signals:
  void messageReceived(QString message);
private:
  QBluetoothServer *bluetoothServer;
  QBluetoothServiceInfo serviceInfo;
  QBluetoothSocket *socket;
  const QString SERVICE_UUID = "1f2d6c5b-6a86-4b30-8b4e-3990043d73f1";
private slots:
  void clientConnected();
  void clientDisconnected();
  void readSocket();
};

Теперь более детально рассмотрим компоненты и содержание методов данного класса.

Устройство может оповестить другие устройства, осуществляющие поиск по Bluetooth путём регистрации сервиса. Для этого используется класс QBluetoothServer. С его помощью можно создать Bluetooth сервер и зарегистрировать на нём сервис, который будет сообщать устройствам, что он из себя представляет.

QBluetoothServer содержит набор методов для установки сервера на устройстве и регистрации сервиса. В частности представляют интерес:

  • Конструктор QBluetoothServer(QBluetoothServiceInfo::Protocol serverType, QObject* parent) – служит для инициализации сервера, принимает в качестве аргументов протокол и родительский QObject. В нашем примере будем использовать протокол RFCOMM.
  • Метод listen(const QBluetoothAddress& address, quint16 port) – начинает прослушку входящих подключений по переданным адресу и порту.
  • Сигнал error(QBluetoothServer::Error error) – вызывается при возникновении ошибок сервера (Bluetooth выключен, сервис уже зарегистрирован и др.), где в качестве аргумента доступна сама ошибка.
  • Сигнал newConnection() – вызывается при новом запросе на подключение.

Остальные методы служат для остановки сервера, получения текущего адреса или порта, проверки статуса и другие. Они не настолько интересны, и о них вы можете почитать в официальной документации.

После того как мы подняли сервер, необходимо зарегистрировать сервис. Сервис представляет собой описание какой-либо службы, выполняющей определённые обязанности. Описывается сервис с помощью объекта QBluetoothServiceInfo путём установки атрибутов выделенными методами. Для решения поставленной выше задачи используем метод startServer():

bluetoothServer = new QBluetoothServer(QBluetoothServiceInfo::RfcommProtocol, this);
connect(bluetoothServer, &QBluetoothServer::newConnection,
  this, &MessengerServer::clientConnected);
QBluetoothAddress bluetoothAddress = QBluetoothLocalDevice().address();
bluetoothServer->listen(bluetoothAddress);

Первой строчкой мы создаём сервер, который в качестве протокола использует RFCOMM. Затем соединяем сигнал о новом подключении со слотом нашего класса. После этого включаем прослушивание на нашем адресе, для чего создаём экземпляр текущего устройства, из которого извлекаем его адрес и передаём методу listen(). Таким образом мы устанавливаем сервер.

Регистрация сервиса требует большего количества кода для указания всех требующихся для его работы параметров:

serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceName, "BT message sender");
serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceDescription,
  "Example message sender");
serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceProvider, "fruct.org");
serviceInfo.setServiceUuid(QBluetoothUuid(SERVICE_UUID));

Здесь устанавливаем название сервиса, описание, поставщика сервиса (например название компании) и уникальный идентификатор (в данном приложении содержится в константе в виде строки и задаётся в формате xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, где x – это шестнадцатеричное число). Первые три атрибута позволяют получить базовое представление о найденном сервисе в то время как четвёртый может использоваться устройствами для поиска конкретного сервиса.

QBluetoothServiceInfo::Sequence classId;
classId << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::SerialPort));
serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList, classId);
classId.prepend(QVariant::fromValue(QBluetoothUuid(SERVICE_UUID)));
serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId);

Конструкция подобного рода использует последовательность (QBluetoothServiceInfo::Sequence) для установки прочих атрибутов. В данном случае мы устанавливаем уникальный идентификатор сервиса. Таким образом сервер даёт знать о том, какие сервисы он предоставляет.

QBluetoothServiceInfo::Sequence publicBrowse;
publicBrowse << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::PublicBrowseGroup));
serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList, publicBrowse);

Данными строчками устанавливаем группу общедоступного поиска, что позволит устройствам свободно находить данный сервис. В противном случае сервис найден не будет.

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

Здесь для доступа к сервису устанавливаем протокол RFCOMM, аналогично используемому сервером.

serviceInfo.registerService(bluetoothAddress);

Наконец, выполняем регистрацию созданного сервиса на адресе, полученном ранее и используемом сервером. С этого момента сервис будет виден при поиске по Bluetooth другими устройствами.

Работа с входящими соединениями


Теперь, когда сервис зарегистрирован и приложение готово принимать входящие соединения, необходимо их обрабатывать. Как упоминалось ранее, сервер приложения должен принимать строку от клиента, разворачивать её и отправлять обратно.

При подключении клиента к серверу мы создаём сокет, представленный в виде экземпляра QBluetoothSocket, который можно получить вызвав метод nextPendingConnection() на экземпляре класса QBluetoothServer. У сокета есть целый набор сигналов, позволяющих отследить его состояние, наиболее полезными из которых являются:

  • connected() – вызывается при создании соединения по сокету.
  • disconnected() – вызывается при разрыве соединения.
  • error(QBluetoothSocket::SocketError error) – вызывается при возникновении ошибки, в качестве аргумента передаётся её тип.
  • readyRead() – вызывается, когда в сокете доступны новые данные для чтения.

Используем их для обработки входящих соединений. Ранее мы прикрепили сигнал newConnection() к слоту clientConnected(), рассмотрим его реализацию.

void MessengerServer::clientConnected() {
  //...
  socket = bluetoothServer->nextPendingConnection();
  connect(socket, &QBluetoothSocket::readyRead, this, &MessengerServer::readSocket);
  connect(socket, &QBluetoothSocket::disconnected, this,  &MessengerServer::clientDisconnected);
}

Объект QBluetoothSocket является наследником QIODevice, как следствие ему доступны методы для чтения линии, символа, выбранного количества символов и т.п. Методы для чтения (как и методы для записи) используют QByteArray, что позволяет передавать не только строки, но и любые другие данные в виде набора байтов. Таким образом возможна передача любых типов данных вне зависимости от содержимого.

В нашем примере для обработки входящих сообщений мы соединили сигнал readyRead() с методом readSocket(), код которого выглядит следующим образом:

void MessengerServer::readSocket() {
  //...
  const QString message = QString::fromUtf8(socket->readLine().trimmed());
  emit messageReceived(message);
  QString reversedMessage;
  for (int i = message.size() - 1; i >= 0; i--) {
    reversedMessage.append(message.at(i));
  }
  socket->write(reversedMessage.toUtf8());
}

Для чтения данных в виде массива байтов мы используем метод readLine(), после чего преобразуем считанную линию в строку, разворачиваем её и отправляем обратно с помощью метода write(), преобразовав обратно в массив байтов. Таким образом реализованный нами сервер способен получать строку от любого другого устройства по Bluetooth и возвращать её обратно в развёрнутом виде.

Поиск сервиса


Теперь, когда сервер реализован, запущен и ждёт входящих соединений, необходимо к нему подключиться. Каким образом возможно найти устройство, которое предоставляет необходимый сервис? Во-первых, необходимо произвести поиск сервисов, доступных на видимых Bluetooth устройствах и только затем к нему подключаться.

Заголовочный файл клиента имеет следующее содержание:

class MessengerClient : public QObject {
  Q_OBJECT
public:
  explicit MessengerClient(QObject *parent = 0);
  ~MessengerClient();
  Q_INVOKABLE void startDiscovery(const QString &messageToSend);
  Q_INVOKABLE void stopDiscovery();
private:
  const QString SERVICE_UUID = "1f2d6c5b-6a86-4b30-8b4e-3990043d73f1";
  QString message;
  QBluetoothSocket *socket = NULL;
  QBluetoothDeviceDiscoveryAgent* discoveryAgent;
  QBluetoothDeviceInfo device;
  QBluetoothLocalDevice localDevice;
  void requestPairing(const QBluetoothAddress &address);
  void startClient(const QBluetoothAddress &address);
  void stopClient();
signals:
  void messageReceived(QString message);
  void clientStatusChanged(QString text);
private slots:
  void deviceDiscovered(const QBluetoothDeviceInfo &deviceInfo);
  void pairingFinished(const QBluetoothAddress &address, QBluetoothLocalDevice::Pairing pairing);
  void pairingError(QBluetoothLocalDevice::Error error);
  void socketConnected();
  void deviceSearchFinished();
  void readSocket();
};

Рассмотрим компоненты, которые необходимы для реализации поиска сервиса и отправки сообщений.

Для поиска сервисов библиотека Qt предоставляет класс QBluetoothServiceDiscoveryAgent. Он позволяет автоматически проверить все устройства на наличие определённого сервиса, который мы ищем по UUID. В дальнейшем, при нахождении сервиса объект данного класса инициирует соответствующий сигнал, с помощью которого мы можем обработать результат поиска. Следует заметить, что использование данного класса требует, чтобы приложение было запущено с повышенными привилегиями. Класс содержит следующие интересующие нас методы:

  • setUuidFilter(const QBluetoothUuid &uuid) – устанавливает UUID, сервис с которым требуется найти. Также есть аналогичный метод для установки нескольких UUID.
  • setRemoteAddress(const QBluetoothAddress &address) – устанавливает адрес устройства, на котором необходимо найти сервис. Может использоваться, если точно известен адрес устройства, которое необходимо найти.
  • start() – запускает поиск сервисов.
  • stop() – останавливает поиск сервисов.
  • discoveredServices() – возвращает список найденных сервисов.
  • clear() – очищает список найденных сервисов.

Для обработки результата полезны сигналы:

  • serviceDiscovered(const QBluetoothServiceInfo &info) – вызывается при обнаружении сервиса, информация о нём передаётся с аргументом.
  • finished() – вызывается при завершении поиска.
  • error(QBluetoothServiceDiscoveryAgent::Error error) – вызывается при возникновении ошибок.

Для поиска нашего конкретного сервиса необходимо установить методом setUuidFilter() фильтр по UUID, который мы указывали при регистрации сервиса и методом start() начать поиск. После этого при обнаружении нашего сервиса будет инициирован сигнал serviceDiscovered(). Экземпляр QBluetoothServiceInfo содержит информацию о найденном сервисе (имя, UUID, информация об устройстве, на котором он зарегистрирован и т.п.). Экземпляр данного класса мы будем использовать для подключения к сервису, о чём будет упомянуто вдальнейшем.

Конкретно в нашем примере будем рассматривать другой класс, не требующий повышенных привилегий – QBluetoothDeviceDiscoveryAgent. С его помощью возможен поиск устройств, а не сервисов, и он не требует повышенных привилегий. Для каждого найденного устройства будем просматривать сервисы, зарегистрированные на устройстве, и если в списке есть наш сервис, то считаем сервис найденным и в дальнейшем будем подключаться к нему.

QBluetoothDeviceDiscoveryAgent состоит из небольшого числа методов для поиска устройств. Наиболее полезными являются следующие:

  • start() – начинает поиск устройств.
  • stop() – останавливает поиск устройств.
  • discoveredDevices() – возвращает список всех найденных устройств.
  • error() – возвращает тип последней возникшей при поиске ошибки. Также есть сигнал, который будет инициирован сразу после возникновения ошибки с типом ошибки в качестве аргумента.
  • errorText() – возвращает текст последней возникшей ошибки.

Также в случае нахождения устройства будет немедленно инициирован сигнал deviceDiscovered(const QBluetoothDeviceInfo &info), который может служить для обработки результата.

Информация о найденных устройствах представлена в виде объекта QDeviceInfo. Из данного объекта можно извлечь данные с помощью специальных методов. Наиболее интересными являются следующие:

  • address() – mac-адрес найденного устройства. Используется при поиске любых устройств кроме macOS и iOS.
  • deviceUuid() – уникальный идентификатор найденного устройства. Используется только при поиске устройств на macOS и iOS.
  • name() – имя найденного устройства.
  • serviceUuids() – список уникальных идентификаторов зарегистрированных сервисов.

Теперь, когда мы знаем как искать сервисы на Bluetooth устройствах попробуем найти наш собственный сервис. В конструкторе инициализируем объект для поиска устройств:

MessengerClient::MessengerClient(QObject *parent) : QObject(parent) {
  //...
  discoveryAgent = new QBluetoothDeviceDiscoveryAgent(localDevice.address());
  connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceDiscovered,
    this, &MessengerClient::deviceDiscovered);
  connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::finished,
    this, &MessengerClient::deviceSearchFinished);
  //...
}

Во-первых, создаём экземпляр QBluetoothDeviceDiscoveryAgent, которому в качестве аргумента передаём адрес текущего Bluetooth устройства. Затем присоединяем два сигнала объекта к нашему текущему: deviceDiscovered() для обработки нового найденного устройства и finished() для обработки завершения поиска.

Метод для начала поиска содержит следующие строчки:

void MessengerClient::startDiscovery(const QString &messageToSend) {
  //...
  this->message = messageToSend;
  discoveryAgent->start();
  //...
}

Здесь мы сохраняем сообщение, которое необходимо передать и начинаем поиск устройств.

Для обработки найденных устройств используется слот deviceDiscovered(), к которому ранее мы уже подключили сигнал:

void MessengerClient::deviceDiscovered(const QBluetoothDeviceInfo &deviceInfo) {
  //...
  if (deviceInfo.serviceUuids().contains(QBluetoothUuid(SERVICE_UUID))) {
    emit clientStatusChanged(QStringLiteral("Device found"));
    discoveryAgent->stop();
    requestPairing(deviceInfo.address());
  }
}

Как упоминалось ранее мы смотрим на список уникальных идентификаторов сервисов для поиска в нём нашего зарегистрированного. При первом найденном устройстве, которое предоставляет искомый сервис, мы завершаем поиск и вызываем метод для установления сопряжения между устройствами.

Сопряжение устройств


Сопряжение устройств является важным аспектом во взаимодействии устройств с помощью Bluetooth. Это подразумевает собой, что два устройства устанавливают между собой доверительные отношения и им доступен более широкий спектр возможностей взаимодействия (например, дистанционное управление). Конкретно в нашем примере сопряжение не требуется, но мы установим его, чтобы разобрать как это делается в общем случае. Установка сопряжения требует повышенных привилегий.

Для сопряжения устройств используется класс QBluetoothLocalDevice. Мы уже использовали его ранее в коде серверной части для получения адреса текущего устройства. Он же используется и для сопряжения устройств. Нас интересуют методы:

  • pairingStatus(const QBluetoothAddress &address) – позволяет получить статус сопряжения между текущим устройством и устройством по адресу. Возвращает одно из значений:
  • requestPairing(const QBluetoothAddress &address, Pairing pairing) – запрашивает изменения статуса сопряжения с устройством (вторым аргументом передаётся Paired для установки сопряжения или Unpaired для разрыва).

и сигналы:

  • pairingFinished(const QBluetoothAddress &address, QBluetoothLocalDevice::Pairing pairing) – возвращается при успешном изменении статуса сопряжения.
  • error(QBluetoothLocalDevice::Error error) – возвращается при ошибке изменения статуса сопряжения (в том числе отмена предложения о сопряжении на одном из устройств).

Адрес удалённого устройства мы можем получить с помощью вызова метода address() на экземпляре QBluetoothDeviceInfo, в дальнейшем будем использовать его при установке сопряжения и подключения к сервису. Теперь попробуем установить сопряжение между двумя устройствами. Для начала добавим подключение к сигналам в конструктор класса клиента:

connect(&localDevice, &QBluetoothLocalDevice::pairingFinished,
  this, &MessengerClient::pairingFinished);
connect(&localDevice, &QBluetoothLocalDevice::error, this, &MessengerClient::pairingError);

Экземпляр QBluetoothLocalDevice в данном случае является полем класса. Слот pairingFinished() содержит строчку, запускающую клиент startClient(address), а pairingError() – отладочный вывод.

Для установки сопряжения мы реализовали метод requestPairing() со следующим содержанием:

void MessengerClient::requestPairing(const QBluetoothAddress &address) {
  //...
  if (localDevice.pairingStatus(address) == QBluetoothLocalDevice::Paired) {
    startClient(address);
  } else {
    localDevice.requestPairing(address, QBluetoothLocalDevice::Paired);
  }
}

Если устройства уже сопряжены, то просто инициируем подключение к серверу, в противном случае запрашиваем сопряжение. В результате при успешном установлении сопряжения также инициируется подключение к серверу, а при ошибке уведомляем пользователя о проблеме.

Подключение к серверу


Экземпляр класса QBluetoothDeviceInfo, соответствующий найденному устройству, содержит метод для получения адреса, которого достаточно для подключения к сервису. Для этого используется QBluetoothSocket, достаточно создать экземпляр данного класса с помощью конструктора, передав ему протокол RFCOMM и вызвать метод connectToService(), которому в качестве аргументов передаётся адрес из экземпляра QBluetoothDeviceInfo и порт, по которому необходимо установить соединение. Чтобы установить соединение с сервисом, необходимо указывать порт 1.

Теперь рассмотрим процесс установки соединения, передачи и приёма данных с помощью сокета. В клиенте используется тот же самый QBluetoothSocket что и на сервере, что позволяет нам использовать рассмотренные ранее сигналы для реализации обработчиков и методы для записи данных в сокет. Метод startClient() устанавливает соединение с устройством, предоставляющим сервис, с помощью сокета:

void MessengerClient::startClient(const QBluetoothDeviceInfo &deviceInfo) {
  //...
  socket = new QBluetoothSocket(QBluetoothServiceInfo::RfcommProtocol, this);
  connect(socket, &QBluetoothSocket::connected, this, &MessengerClient::socketConnected);
  connect(socket, &QBluetoothSocket::readyRead, this, &MessengerClient::readSocket);
  socket->connectToService(deviceInfo.address(), 1);
}

Создаём экземпляр сокета с протоколом RFCOMM и подключаем его сигналы к слотам нашего класса. Затем вызовом метода connectToService() подключаемся к другому устройству. Следует заметить, что если бы мы использовали класс QBluetoothServiceInfo, который позволяет получить информацию о найденных сервисах в виде экземпляров QBluetoothServiceInfo, то достаточно было бы вызвать метод connectToService() с одним аргументом, принимающим информацию о сервисе.

Метод socketConnected() вызывается при установке подключения по сокету, внутри него мы отправляем данные на сервер:

void MessengerClient::socketConnected() {
  //...
  socket->write(message.toUtf8());
}


Здесь используется тот же самый класс сокета, что и на сервере, так что мы можем передавать любые данные в виде массива байтов.

Как мы помним, код сервера позволяет получить строку, развернуть её и вернуть нам, для обработки входящего сообщения мы соединили слот readSocket() с сигналом readyRead(). Выглядит этот слот следующим образом:

void MessengerClient::readSocket() {
  //...
  QString receivedMessage = QString::fromUtf8(socket->readLine().trimmed());
  emit messageReceived(receivedMessage);
}

Результат


В итоге мы покрыли большую часть функционала, требующегося для реализации сервера и клиента для передачи данных любого рода с между ними. Также рассмотрели процедуру поиска устройств. Материала, упомянутого в статье, достаточно для реализации передачи любых данных между двумя устройствами. Код приложения-примера доступен на GitHub.

Технические вопросы можно также обсудить на канале русскоязычного сообщества Sailfish OS в Telegram или группе ВКонтакте.

Автор: Сергей Аверкиев
Tags:sailfish osqtbluetooth
Hubs: Development of mobile applications Qt Development for Sailfish OS
Total votes 5: ↑5 and ↓0 +5
Views3K

Popular right now