qohosbluetoothsocket.cpp

Go to the documentation of this file.

// 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 "qohosbluetoothsocket_p.h"
 
#include <QtBluetooth/private/qohosbluetoothaccess_p.h>
#include <QtBluetooth/private/qohosbluetoothcommon_p.h>
#include <QtBluetooth/private/qohosbluetoothenums_p.h>
#include <QtBluetooth/private/qohosbluetoothremotedevice_p.h>
 
#include <QtCore/q26numeric.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/private/qcore_ohos_p.h>
#include <QtCore/private/qnapi_p.h>
#include <QtCore/private/qohosjstools_p.h>
#include <QtCore/private/qohoslogger_p.h>
 
#include <cstddef>
#include <cstring>
#include <memory>
#include <optional>
#include <string>
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_LOGGING_CATEGORY(QT_BT_OHOS)
 
namespace QtOhosBluetooth {
 
namespace {
 
std::shared_ptr<int> makeSppSocketHandle(int socketDescriptor, const char *closeCallExpression)
{
    return QtOhos::makeSharedPtrWithAttachedExtraData(
        std::make_shared<int>(socketDescriptor),
        QtOhos::makeDestroyNotifier(
            [socketDescriptor, closeCallExpression]() {
                QOhosJsThreadGateway::invoke(
                    [socketDescriptor, closeCallExpression](QOhosJsState &jsState) {
                        try {
                            jsState.eval(closeCallExpression, {socketDescriptor});
                        } catch (const Napi::Error &error) {
                            const auto errorCode =
                                tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)
                                    .value_or(QOhosBluetoothErrorCode::OperationFailed);
                            qOhosPrintfWarning(
                                "%s: cannot close the socket %d with %s, error code: %u",
                                Q_FUNC_INFO, socketDescriptor, closeCallExpression,
                                qToUnderlying(errorCode));
                        }
                    });
            }));
}
 
}
 
std::shared_ptr<int> makeSppClientSocketHandle(int socketDescriptor)
{
    return makeSppSocketHandle(socketDescriptor, "@ohos.bluetooth.socket.sppCloseClientSocket(*)");
}
 
std::shared_ptr<int> makeSppServerSocketHandle(int socketDescriptor)
{
    return makeSppSocketHandle(socketDescriptor, "@ohos.bluetooth.socket.sppCloseServerSocket(*)");
}
 
namespace {
 
using SppType = QtOhosBluetooth::enums::ohos::bluetooth::socket::SppType;
 
std::shared_ptr<void> registerSocketSppReadListener(
    QOhosJsState &jsState, int socketDescriptor, QOhosConsumer<QByteArray> sppReadListener,
    QOhosConsumer<QOhosBluetoothErrorCode> errorCodeConsumer)
{
    return registerQOhosOnOffMethodsBasedEventHandler(
        jsState.eval<QNapi::Object>("@ohos.bluetooth.socket"), "sppRead",
        [sppReadListener = std::move(sppReadListener)](const QOhosCallbackInfo &cbInfo) {
            auto arrayBuffer = cbInfo.getFirstArg<QNapi::ArrayBuffer>(Q_FUNC_INFO);
            sppReadListener(
                QByteArray(
                    static_cast<const char *>(arrayBuffer.Data()),
                    static_cast<qsizetype>(arrayBuffer.ByteLength())));
        },
        {
            .extraOnArg = std::make_optional(QNapi::ValueWrapper(socketDescriptor)),
            .extraOffArg = std::make_optional(QNapi::ValueWrapper(socketDescriptor)),
            .optOnCallExceptionHandler =
                [errorCodeConsumer = std::move(errorCodeConsumer)](const Napi::Error &error) {
                    errorCodeConsumer(
                        tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)
                            .value_or(QOhosBluetoothErrorCode::OperationFailed));
                },
        });
}
 
std::shared_ptr<void> registerSocketSppReadHandler(
    int socketDescriptor, QOhosConsumer<QByteArray> receivedDataConsumer,
    QOhosConsumer<QOhosBluetoothErrorCode> errorCodeConsumer)
{
    auto sharedReceivedDataConsumer = QtOhos::moveToSharedPtr(std::move(receivedDataConsumer));
    auto weakReceivedDataConsumer = QtOhos::makeWeakPtr(sharedReceivedDataConsumer);
 
    auto socketSppReadHandler = QOhosJsThreadGateway::eval(
        [&](QOhosJsState &jsState) {
            return registerSocketSppReadListener(
                jsState, socketDescriptor,
                [weakReceivedDataConsumer](QByteArray receivedData) {
                    QtOhos::invokeInQtThread(
                        [weakReceivedDataConsumer, receivedData = std::move(receivedData)]() {
                            auto receivedDataConsumer = weakReceivedDataConsumer.lock();
                            if (receivedDataConsumer)
                                (*receivedDataConsumer)(std::move(receivedData));
                        });
                },
                std::move(errorCodeConsumer));
        },
        Q_FUNC_INFO);
 
    if (!socketSppReadHandler)
        return nullptr;
 
    return QtOhos::makeSharedPtrWithAttachedExtraData(
        socketSppReadHandler, sharedReceivedDataConsumer);
}
 
std::optional<bool> tryReadSocketConnectedState(QOhosJsState &jsState, int socketDescriptor)
{
    try {
        return jsState
            .eval<QNapi::Boolean>(
                "@ohos.bluetooth.socket.isConnected(*)", {socketDescriptor})
            .Value();
    } catch (const Napi::Error &error) {
        const auto errorCode =
            tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)
                .value_or(QOhosBluetoothErrorCode::OperationFailed);
        qOhosPrintfWarning(
            "%s: cannot read the socket connected state, error code: %u", Q_FUNC_INFO,
            qToUnderlying(errorCode));
        return std::nullopt;
    }
}
 
std::optional<std::string> tryGetDeviceIdFromSocket(int socket)
{
    if (socket == invalidSocketDescriptor)
        return std::nullopt;
 
    return QOhosJsThreadGateway::eval(
        [&](QOhosJsState &jsState) -> std::optional<std::string> {
            try {
                return jsState.eval<QNapi::String>(
                    "@ohos.bluetooth.socket.getDeviceId(*)", {socket});
            } catch (const Napi::Error &error) {
                if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
                    qOhosPrintfWarning(
                        "%s: cannot read the device id of the socket %d, error code: %u",
                        Q_FUNC_INFO, socket, qToUnderlying(*optErrorCode));
                }
                return std::nullopt;
            }
        });
}
 
}
 
QOhosBluetoothSocketProxy::QOhosBluetoothSocketProxy()
{
    QObject::connect(
        QOhosBluetoothAccessProxy::instance().get(),
        &QOhosBluetoothAccessProxy::stateChanged,
        this,
        [this](QOhosBluetoothAccessProxy::BluetoothState bluetoothState) {
            if (bluetoothState == QOhosBluetoothAccessProxy::BluetoothState::STATE_ON)
                return;
 
            if (m_pendingConnectRequestId) {
                qCWarning(
                    QT_BT_OHOS, "%s: bluetooth is turned off. Aborting the connect request ...",
                    Q_FUNC_INFO);
                onConnectFailed(
                    *m_pendingConnectRequestId, QOhosBluetoothErrorCode::BluetoothDisabled);
                return;
            }
 
            if (!m_jsScopeData)
                return;
 
            qCWarning(
                QT_BT_OHOS, "%s: bluetooth is turned off. Closing the socket ...", Q_FUNC_INFO);
            reportError(QOhosBluetoothErrorCode::BluetoothDisabled);
            close();
        });
}
 
std::unordered_map<int, std::shared_ptr<int>> &QOhosBluetoothSocketProxy::pendingSocketHandles()
{
    static std::unordered_map<int, std::shared_ptr<int>> handles;
    return handles;
}
 
bool QOhosBluetoothSocketProxy::registerPendingSocketHandle(std::shared_ptr<int> socketHandle)
{
    if (!socketHandle) {
        qCCritical(QT_BT_OHOS, "%s: no socket handle to register", Q_FUNC_INFO);
        return false;
    }
 
    const auto socketDescriptor = *socketHandle;
 
    auto &handles = pendingSocketHandles();
    if (handles.find(socketDescriptor) != handles.end()) {
        qCCritical(
            QT_BT_OHOS,
            "%s: socket descriptor %d is already registered as pending. Rejecting the socket ...",
            Q_FUNC_INFO, socketDescriptor);
        return false;
    }
 
    handles[socketDescriptor] = std::move(socketHandle);
 
    return true;
}
 
void QOhosBluetoothSocketProxy::dropPendingSocketHandle(int socketDescriptor)
{
    pendingSocketHandles().erase(socketDescriptor);
}
 
std::shared_ptr<int> QOhosBluetoothSocketProxy::takePendingSocketHandle(int socketDescriptor)
{
    auto &handles = pendingSocketHandles();
    auto found = handles.find(socketDescriptor);
    if (found == handles.end())
        return nullptr;
 
    auto socketHandle = std::move(found->second);
    handles.erase(found);
    return socketHandle;
}
 
bool QOhosBluetoothSocketProxy::connect(const QString &deviceId, const QString &uuid, bool secure)
{
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
        reportError(QOhosBluetoothErrorCode::PermissionDenied);
        return false;
    }
 
    const auto connectRequestId = ++m_connectRequestsCounter;
    m_pendingConnectRequestId = connectRequestId;
 
    auto selfRef = QtOhos::makeQThreadSafeRef(this);
    auto optConnectErrorCode = QOhosJsThreadGateway::eval(
        [&](QOhosJsState &jsState) -> std::optional<QOhosBluetoothErrorCode> {
            auto sppOptions = QNapi::makeObject(
                jsState.env(),
                {
                    {"uuid", uuid.toStdString()},
                    {"secure", secure},
                    {"type", jsState.mapOhosEnumToJs(SppType::SPP_RFCOMM)},
                });
 
            try {
                jsState.eval(
                    "@ohos.bluetooth.socket.sppConnect(*)",
                    {
                        deviceId.toStdString(),
                        sppOptions,
                        [selfRef, connectRequestId](const QNapi::CallbackInfo &callbackInfo) {
                            QNapi::Value error;
                            QNapi::Value data;
                            callbackInfo.getLeadingArgs(Q_FUNC_INFO, error, data);
                            auto socketId = data.IsNumber()
                                ? QNapi::checkedCast<QNapi::Number>(data).Int32Value()
                                : invalidSocketDescriptor;
 
                            if (socketId == invalidSocketDescriptor) {
                                const auto errorCode =
                                    tryGetKnownErrorCode(error, Q_FUNC_INFO)
                                        .value_or(QOhosBluetoothErrorCode::OperationFailed);
                                qOhosPrintfError(
                                    "%s: sppConnect() failed with error code: %u", Q_FUNC_INFO,
                                    qToUnderlying(errorCode));
                                selfRef.visitInQtThreadIfAlive(
                                    [connectRequestId, errorCode](auto &self) {
                                        self.onConnectFailed(connectRequestId, errorCode);
                                    });
                                return;
                            }
 
                            auto socketHandle = makeSppClientSocketHandle(socketId);
 
                            selfRef.visitInQtThreadIfAlive(
                                [connectRequestId, socketHandle](auto &self) {
                                    self.onSocketConnected(connectRequestId, socketHandle);
                                });
                        }
                    });
                return std::nullopt;
            } catch (const Napi::Error &error) {
                return tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO);
            }
        });
 
    if (optConnectErrorCode) {
        qCCritical(
            QT_BT_OHOS, "%s: sppConnect() failed with error code: %u", Q_FUNC_INFO,
            qToUnderlying(*optConnectErrorCode));
        onConnectFailed(connectRequestId, *optConnectErrorCode);
        return false;
    }
 
    m_deviceId = deviceId.toStdString();
 
    return true;
}
 
void QOhosBluetoothSocketProxy::onSocketConnected(
    std::uint64_t connectRequestId, std::shared_ptr<int> socketHandle)
{
    if (m_pendingConnectRequestId != connectRequestId) {
        qCDebug(
            QT_BT_OHOS,
            "%s: the connection has been closed before it was established. Letting the socket "
            "handle close the socket ...",
            Q_FUNC_INFO);
        return;
    }
 
    m_pendingConnectRequestId.reset();
 
    if (!takeOverSocket(std::move(socketHandle))) {
        m_deviceId.reset();
        reportError(QOhosBluetoothErrorCode::OperationFailed);
    }
}
 
void QOhosBluetoothSocketProxy::onConnectFailed(
    std::uint64_t connectRequestId, QOhosBluetoothErrorCode errorCode)
{
    if (m_pendingConnectRequestId != connectRequestId)
        return;
 
    m_pendingConnectRequestId.reset();
    m_deviceId.reset();
 
    reportError(errorCode);
}
 
bool QOhosBluetoothSocketProxy::takeOverSocket(std::shared_ptr<int> socketHandle)
{
    if (!socketHandle) {
        qCCritical(QT_BT_OHOS, "%s: no socket handle to take over", Q_FUNC_INFO);
        return false;
    }
 
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
        return false;
 
    auto selfRef = QtOhos::makeQThreadSafeRef(this);
    auto optSubscriptionErrorCode = std::make_shared<std::optional<QOhosBluetoothErrorCode>>();
 
    auto sppReadHandlerHandle = registerSocketSppReadHandler(
        *socketHandle,
        [selfRef](QByteArray receivedData) {
            if (receivedData.isEmpty())
                return;
 
            selfRef.visitInQtThreadIfAlive(
                [receivedData = std::move(receivedData)](auto &self) {
                    Q_EMIT self.dataReceived(receivedData);
                });
        },
        [optSubscriptionErrorCode](QOhosBluetoothErrorCode errorCode) {
            *optSubscriptionErrorCode = errorCode;
        });
 
    if (!sppReadHandlerHandle) {
        qCCritical(
            QT_BT_OHOS,
            "%s: cannot register the SPP read handler, error code: %u. Socket is not connected.",
            Q_FUNC_INFO,
            qToUnderlying(
                optSubscriptionErrorCode->value_or(QOhosBluetoothErrorCode::OperationFailed)));
        return false;
    }
 
    m_jsScopeData = QtOhos::makeProxyWithJsThreadDeleter(
        QtOhos::moveToSharedPtr(
            JsScopeData {
                .socketHandle = socketHandle,
                .sppReadHandlerHandle = std::move(sppReadHandlerHandle),
            }));
 
    const auto socketDescriptor = *socketHandle;
    QMetaObject::invokeMethod(
        this,
        [this, socketDescriptor]() {
            Q_EMIT connected(socketDescriptor);
        },
        Qt::QueuedConnection);
 
    return true;
}
 
bool QOhosBluetoothSocketProxy::write(const char *data, qint64 maxSize)
{
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
        reportError(QOhosBluetoothErrorCode::PermissionDenied);
        return false;
    }
 
    if (!m_jsScopeData) {
        qCWarning(QT_BT_OHOS, "%s: the socket is already closed", Q_FUNC_INFO);
        reportError(QOhosBluetoothErrorCode::OperationFailed);
        return false;
    }
 
    const auto socketDescriptor = *m_jsScopeData->socketHandle;
 
    struct WriteOutcome
    {
        std::optional<QOhosBluetoothErrorCode> optErrorCode = std::nullopt;
        bool socketStillConnected = true;
    };
 
    const auto writeSize = q26::saturate_cast<std::size_t>(maxSize);
    const auto writeOutcome = QOhosJsThreadGateway::eval(
        [&](QOhosJsState &jsState) -> WriteOutcome {
            try {
                auto arrayBuffer = QNapi::ArrayBuffer::New(jsState.env(), writeSize);
                std::memcpy(arrayBuffer.Data(), data, writeSize);
                jsState.eval("@ohos.bluetooth.socket.sppWrite(*)", {socketDescriptor, arrayBuffer});
                return {};
            } catch (const Napi::Error &error) {
                return {
                    .optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO),
                    .socketStillConnected =
                        tryReadSocketConnectedState(jsState, socketDescriptor).value_or(true),
                };
            }
        });
 
    if (!writeOutcome.optErrorCode)
        return true;
 
    reportError(*writeOutcome.optErrorCode);
 
    if (!writeOutcome.socketStillConnected) {
        qCWarning(
            QT_BT_OHOS, "%s: the peer is no longer connected. Closing the socket ...", Q_FUNC_INFO);
        close();
    }
 
    return false;
}
 
void QOhosBluetoothSocketProxy::close()
{
    if (!m_jsScopeData && !m_pendingConnectRequestId)
        return;
 
    m_jsScopeData.reset();
    m_pendingConnectRequestId.reset();
    m_deviceId.reset();
 
    QMetaObject::invokeMethod(this, &QOhosBluetoothSocketProxy::disconnected, Qt::QueuedConnection);
}
 
std::optional<QString> QOhosBluetoothSocketProxy::tryGetPeerDeviceAddress() const
{
    const auto peerDeviceIdFromSocket = m_jsScopeData
        ? tryGetDeviceIdFromSocket(*m_jsScopeData->socketHandle)
        : std::optional<std::string>();
    const auto &optPeerDeviceId = peerDeviceIdFromSocket
        ? peerDeviceIdFromSocket
        : m_deviceId;
 
    return optPeerDeviceId
        ? std::optional(QString::fromStdString(*optPeerDeviceId))
        : std::nullopt;
}
 
std::optional<QString> QOhosBluetoothSocketProxy::tryGetPeerDeviceName() const
{
    const auto deviceId = tryGetPeerDeviceAddress();
    if (!deviceId)
        return std::nullopt;
 
    auto remoteDeviceProxy = QOhosBluetoothRemoteDeviceProxy::instance();
    return remoteDeviceProxy->tryGetRemoteDeviceName(*deviceId);
}
 
void QOhosBluetoothSocketProxy::reportError(QOhosBluetoothErrorCode errorCode)
{
    QMetaObject::invokeMethod(
        this,
        [this, errorCode]() {
            Q_EMIT errorOccurred(errorCode);
        },
        Qt::QueuedConnection);
}
 
}
 
QT_END_NAMESPACE
 
#include "moc_qohosbluetoothsocket_p.cpp"