Revision control
+ // Copyright (C) 2026 The Qt Company Ltd.
+ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+ #include "qbluetoothserver_ohos_p.h"
+
+ #include <QtBluetooth/qbluetoothserver.h>
+ #include <QtBluetooth/qbluetoothsocket.h>
+ #include <QtBluetooth/private/qbluetoothserver_p.h>
+ #include <QtBluetooth/private/qohosbluetoothaccess_p.h>
+ #include <QtBluetooth/private/qohosbluetoothcommon_p.h>
+ #include <QtBluetooth/private/qohosbluetoothserver_p.h>
+ #include <QtBluetooth/private/qohosbluetoothsocket_p.h>
+
+ #include <QtCore/q20utility.h>
+ #include <QtCore/qloggingcategory.h>
+
+ #include <memory>
+
+ QT_BEGIN_NAMESPACE
+
+ using QtOhosBluetooth::QOhosBluetoothErrorCode;
+
+ Q_DECLARE_LOGGING_CATEGORY(QT_BT_OHOS)
+
+ namespace {
+
+ QBluetoothServer::Error mapToServerError(QOhosBluetoothErrorCode errorCode)
+ {
+ switch (errorCode) {
+ case QOhosBluetoothErrorCode::PermissionDenied:
+ return QBluetoothServer::MissingPermissionsError;
+ case QOhosBluetoothErrorCode::CapabilityNotSupported:
+ case QOhosBluetoothErrorCode::ProfileNotSupported:
+ return QBluetoothServer::UnsupportedProtocolError;
+ case QOhosBluetoothErrorCode::InputOutput:
+ return QBluetoothServer::InputOutputError;
+ case QOhosBluetoothErrorCode::BluetoothDisabled:
+ case QOhosBluetoothErrorCode::ServiceStopped:
+ return QBluetoothServer::PoweredOffError;
+ case QOhosBluetoothErrorCode::InvalidParameter:
+ case QOhosBluetoothErrorCode::UserDidNotRespond:
+ case QOhosBluetoothErrorCode::UserRefused:
+ case QOhosBluetoothErrorCode::OperationFailed:
+ break;
+ }
+
+ return QBluetoothServer::UnknownError;
+ }
+
+ }
+
+ QBluetoothServerPrivate::QBluetoothServerPrivate(
+ QBluetoothServiceInfo::Protocol sType, QBluetoothServer *parent)
+ : serverType(sType)
+ , q_ptr(parent)
+ {
+ }
+
+ QBluetoothServerPrivate::~QBluetoothServerPrivate() = default;
+
+ bool QBluetoothServerPrivate::isListening() const
+ {
+ return socket != nullptr && socket->state() == QBluetoothSocket::SocketState::ListeningState;
+ }
+
+ void QBluetoothServerPrivate::resetServerContext()
+ {
+ socket = nullptr;
+ m_bluetoothServerProxyContext.reset();
+ }
+
+ void QBluetoothServer::close()
+ {
+ d_ptr->resetServerContext();
+ }
+
+ bool QBluetoothServer::listen(const QBluetoothAddress &address, quint16 port)
+ {
+ if (!address.isNull()) {
+ qCWarning(
+ QT_BT_OHOS,
+ "%s: HarmonyOS does not support multi device adapters. Ignoring local adapter address ...",
+ Q_FUNC_INFO);
+ }
+
+ const auto reportError = [this](Error error) {
+ d_ptr->m_lastError = error;
+ QMetaObject::invokeMethod(
+ this,
+ [this, error]() {
+ Q_EMIT errorOccurred(error);
+ },
+ Qt::QueuedConnection);
+ };
+
+ if (serverType() != QBluetoothServiceInfo::RfcommProtocol) {
+ reportError(UnsupportedProtocolError);
+ return false;
+ }
+
+ if (!QtOhosBluetooth::checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
+ reportError(MissingPermissionsError);
+ return false;
+ }
+
+ auto accessProxy = QtOhosBluetooth::QOhosBluetoothAccessProxy::instance();
+ if (accessProxy->tryGetBluetoothState()
+ != QtOhosBluetooth::QOhosBluetoothAccessProxy::BluetoothState::STATE_ON) {
+ reportError(PoweredOffError);
+ return false;
+ }
+
+ if (isListening()) {
+ reportError(ServiceAlreadyRegisteredError);
+ return false;
+ }
+
+ if (d_ptr->m_bluetoothServerProxyContext
+ && !d_ptr->m_bluetoothServerProxyContext->bluetoothServerProxy->isServiceRegistered()) {
+ d_ptr->resetServerContext();
+ }
+
+ if (!d_ptr->m_bluetoothServerProxyContext) {
+ d_ptr->m_bluetoothServerProxyContext = QtOhosBluetooth::makeServerProxyContext(port);
+ if (!d_ptr->m_bluetoothServerProxyContext) {
+ reportError(ServiceAlreadyRegisteredError);
+ return false;
+ }
+ d_ptr->m_bluetoothServerProxyContext->securityFlags = d_ptr->securityFlags;
+ d_ptr->socket = d_ptr->m_bluetoothServerProxyContext->bluetoothSocket.get();
+
+ auto serverProxy = d_ptr->m_bluetoothServerProxyContext->bluetoothServerProxy.get();
+
+ QObject::connect(
+ serverProxy, &QtOhosBluetooth::QOhosBluetoothServerProxy::clientAccepted,
+ this,
+ [this](int clientSocketDescriptor) {
+ auto context = d_ptr->m_bluetoothServerProxyContext;
+ if (!context) {
+ QtOhosBluetooth::QOhosBluetoothSocketProxy::dropPendingSocketHandle(
+ clientSocketDescriptor);
+ return;
+ }
+
+ if (q20::cmp_greater_equal(
+ context->pendingConnectionSockets.size(),
+ d_ptr->maxPendingConnections)) {
+ qCDebug(
+ QT_BT_OHOS,
+ "%s: maximum number of pending connections reached. Rejecting the client ...",
+ Q_FUNC_INFO);
+ QtOhosBluetooth::QOhosBluetoothSocketProxy::dropPendingSocketHandle(
+ clientSocketDescriptor);
+ return;
+ }
+
+ auto pendingConnectionSocket = std::make_unique<QBluetoothSocket>();
+ const auto socketDescriptorSet = pendingConnectionSocket->setSocketDescriptor(
+ clientSocketDescriptor, QBluetoothServiceInfo::RfcommProtocol,
+ QBluetoothSocket::SocketState::ConnectedState, QBluetoothSocket::ReadWrite);
+
+ if (!socketDescriptorSet) {
+ QtOhosBluetooth::QOhosBluetoothSocketProxy::dropPendingSocketHandle(
+ clientSocketDescriptor);
+ return;
+ }
+
+ context->pendingConnectionSockets.push_back(std::move(pendingConnectionSocket));
+ Q_EMIT newConnection();
+ });
+
+ QObject::connect(
+ serverProxy, &QtOhosBluetooth::QOhosBluetoothServerProxy::errorOccurred,
+ this,
+ [this](QOhosBluetoothErrorCode errorCode) {
+ d_ptr->m_lastError = mapToServerError(errorCode);
+ Q_EMIT errorOccurred(d_ptr->m_lastError);
+ });
+
+ QObject::connect(
+ serverProxy, &QtOhosBluetooth::QOhosBluetoothServerProxy::acceptingStopped,
+ this,
+ [this]() {
+ auto context = d_ptr->m_bluetoothServerProxyContext;
+ if (context && context->bluetoothServerProxy->isServiceRegistered())
+ return;
+
+ if (d_ptr->socket)
+ d_ptr->socket->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
+ });
+ }
+
+ d_ptr->socket->setSocketState(QBluetoothSocket::SocketState::ListeningState);
+ return true;
+ }
+
+ void QBluetoothServer::setMaxPendingConnections(int numConnections)
+ {
+ d_ptr->maxPendingConnections = numConnections;
+ }
+
+ bool QBluetoothServer::hasPendingConnections() const
+ {
+ auto context = d_ptr->m_bluetoothServerProxyContext;
+ return context && !context->pendingConnectionSockets.empty();
+ }
+
+ QBluetoothSocket *QBluetoothServer::nextPendingConnection()
+ {
+ auto context = d_ptr->m_bluetoothServerProxyContext;
+ if (!context || context->pendingConnectionSockets.empty())
+ return nullptr;
+
+ auto pendingConnectionSocket = std::move(context->pendingConnectionSockets.front());
+ context->pendingConnectionSockets.pop_front();
+
+ return pendingConnectionSocket.release();
+ }
+
+ QBluetoothAddress QBluetoothServer::serverAddress() const
+ {
+ return {};
+ }
+
+ quint16 QBluetoothServer::serverPort() const
+ {
+ auto context = d_ptr->m_bluetoothServerProxyContext;
+ return context ? context->port : 0;
+ }
+
+ void QBluetoothServer::setSecurityFlags(QBluetooth::SecurityFlags security)
+ {
+ if (isListening()) {
+ qCWarning(
+ QT_BT_OHOS,
+ "%s: the security flags must be set before listen(). Ignoring the new flags ...",
+ Q_FUNC_INFO);
+ return;
+ }
+
+ d_ptr->securityFlags = security;
+ }
+
+ QBluetooth::SecurityFlags QBluetoothServer::securityFlags() const
+ {
+ return d_ptr->securityFlags;
+ }
+
+ QT_END_NAMESPACE