qohosbluetoothdevicediscovery.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 "qohosbluetoothdevicediscovery_p.h"
 
#include <QtBluetooth/private/qohosbluetoothcommon_p.h>
#include <QtBluetooth/private/qohosbluetoothremotedevice_p.h>
 
#include <QtCore/qloggingcategory.h>
#include <QtCore/private/qnapi_p.h>
#include <QtCore/private/qohosjstools_p.h>
#include <QtCore/private/qohoslogger_p.h>
 
#include <chrono>
#include <optional>
 
using namespace std::chrono_literals;
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_LOGGING_CATEGORY(QT_BT_OHOS)
 
namespace QtOhosBluetooth {
 
namespace {
 
constexpr qint16 unknownRssi = 0;
 
std::optional<bool> tryReadBluetoothDiscoveringState(QOhosJsState &jsState)
{
    if (!isBluetoothEnabled(jsState))
        return false;
 
    try {
        return jsState.eval<QNapi::Boolean>("@ohos.bluetooth.connection.isBluetoothDiscovering()").Value();
    } catch (const Napi::Error &error) {
        if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
            qOhosPrintfWarning(
                "%s: cannot read the bluetooth discovering state, error code: %u", Q_FUNC_INFO,
                qToUnderlying(*optErrorCode));
        }
        return std::nullopt;
    }
}
 
bool requestBluetoothDiscoveryStop(QOhosJsState &jsState)
{
    const auto optDiscovering = tryReadBluetoothDiscoveringState(jsState);
    if (optDiscovering && !*optDiscovering)
        return true;
 
    try {
        jsState.eval("@ohos.bluetooth.connection.stopBluetoothDiscovery()");
    } catch (const Napi::Error &error) {
        if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
            qOhosPrintfWarning(
                "%s: cannot stop the bluetooth discovery, error code: %u", Q_FUNC_INFO, qToUnderlying(*optErrorCode));
        }
        return false;
    }
 
    return true;
}
 
std::vector<std::string> readPairedDeviceIds(QOhosJsState &jsState)
{
    if (!isBluetoothEnabled(jsState))
        return {};
 
    try {
        return QNapi::getArrayElements<std::vector<std::string>, QNapi::String>(
            jsState.eval<QNapi::Array>("@ohos.bluetooth.connection.getPairedDevices()"),
            [](QNapi::String &&pairedDeviceId) {
                return pairedDeviceId.Utf8Value();
            });
    } catch (const Napi::Error &error) {
        if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
            qOhosPrintfWarning(
                "%s: cannot read the paired devices, error code: %u", Q_FUNC_INFO, qToUnderlying(*optErrorCode));
        }
        return {};
    }
}
 
std::vector<DiscoveryResult> readPairedDevices(QOhosJsState &jsState)
{
    auto pairedDeviceIds = readPairedDeviceIds(jsState);
 
    std::vector<DiscoveryResult> pairedDevices;
    pairedDevices.reserve(pairedDeviceIds.size());
    for (auto &pairedDeviceId : pairedDeviceIds) {
        if (isRemoteDeviceLowEnergyOnly(jsState, pairedDeviceId))
            continue;
 
        auto pairedDeviceName = readRemoteDeviceName(jsState, pairedDeviceId);
        const auto optPairedDeviceClass = readRemoteDeviceClass(jsState, pairedDeviceId);
 
        pairedDevices.push_back(
            DiscoveryResult {
                .deviceId = std::move(pairedDeviceId),
                .deviceName = pairedDeviceName
                    ? *pairedDeviceName
                    : std::string(),
                .classOfDevice = optPairedDeviceClass.value_or(0),
                .rssi = unknownRssi,
            });
    }
 
    return pairedDevices;
}
 
}
 
DiscoveryResult DiscoveryResult::makeFromOhosDiscoveryResultObject(
    QOhosJsState &jsState, QNapi::Object discoveryResultObject)
{
    auto deviceId = discoveryResultObject.get<QNapi::String>("deviceId").Utf8Value();
 
    auto deviceName = discoveryResultObject.get<QNapi::String>("deviceName").Utf8Value();
    if (deviceName.empty()) {
        if (auto optRemoteDeviceName = readRemoteDeviceName(jsState, deviceId))
            deviceName = std::move(*optRemoteDeviceName);
    }
 
    return DiscoveryResult {
        .deviceId = std::move(deviceId),
        .deviceName = std::move(deviceName),
        .classOfDevice = discoveryResultObject.get<QNapi::Number>("deviceClass.classOfDevice").Uint32Value(),
        .rssi = static_cast<qint16>(discoveryResultObject.get<QNapi::Number>("rssi").Int32Value()),
    };
}
 
QOhosBluetoothDeviceDiscoveryAgentProxy::QOhosBluetoothDeviceDiscoveryAgentProxy()
    : m_accessProxy(QOhosBluetoothAccessProxy::instance())
{
    QObject::connect(
        m_accessProxy.get(), &QOhosBluetoothAccessProxy::stateChanged, this,
        [this](QOhosBluetoothAccessProxy::BluetoothState bluetoothState) {
            if (bluetoothState == QOhosBluetoothAccessProxy::BluetoothState::STATE_ON)
                return;
 
            if (!m_discoveryStoppedPollTimer.isActive())
                return;
 
            resetDiscoveryTracking();
            Q_EMIT bluetoothPoweredOff();
        });
 
    constexpr auto discoveryStoppedPollInterval = 500ms;
    m_discoveryStoppedPollTimer.setInterval(discoveryStoppedPollInterval);
    QObject::connect(
        &m_discoveryStoppedPollTimer, &QTimer::timeout, this,
        [this]() {
            if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
                resetDiscoveryTracking();
                m_discoveredDevicesConsumerHandle.reset();
                Q_EMIT missingPermission();
                return;
            }
 
            if (tryCheckBluetoothDiscovering().value_or(true))
                return;
 
            resetDiscoveryTracking();
            Q_EMIT discoveryStopped();
        });
 
    constexpr auto discoveryStoppedTimeout = 30s;
    m_discoveryStoppedTimeoutTimer.setSingleShot(true);
    m_discoveryStoppedTimeoutTimer.setInterval(discoveryStoppedTimeout);
    QObject::connect(
        &m_discoveryStoppedTimeoutTimer, &QTimer::timeout, this,
        [this]() {
            resetDiscoveryTracking();
            Q_EMIT discoveryStopFailed();
        });
}
 
std::shared_ptr<QOhosBluetoothDeviceDiscoveryAgentProxy> QOhosBluetoothDeviceDiscoveryAgentProxy::instance()
{
    static std::weak_ptr<QOhosBluetoothDeviceDiscoveryAgentProxy> weakInstance;
 
    auto instance = weakInstance.lock();
    if (!instance) {
        instance = std::shared_ptr<QOhosBluetoothDeviceDiscoveryAgentProxy>(
            new QOhosBluetoothDeviceDiscoveryAgentProxy());
        weakInstance = instance;
    }
 
    return instance;
}
 
bool QOhosBluetoothDeviceDiscoveryAgentProxy::ensureDiscoveredDevicesConsumerRegistered()
{
    if (m_discoveredDevicesConsumerHandle)
        return true;
 
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
        return false;
 
    auto selfRef = QtOhos::makeQThreadSafeRef(this);
    m_discoveredDevicesConsumerHandle = QOhosJsThreadGateway::eval(
        [&](QOhosJsState &jsState) -> std::shared_ptr<void> {
            auto discoveredDevicesConsumerHandle = registerQOhosOnOffMethodsBasedEventHandler(
                jsState.eval<QNapi::Object>("@ohos.bluetooth.connection"), "discoveryResult",
                [selfRef](const QOhosCallbackInfo &cbInfo) {
                    auto resultArray = cbInfo.getFirstArg<QNapi::Array>(Q_FUNC_INFO);
                    auto discoveredDevices =
                        QNapi::getArrayElements<std::vector<DiscoveryResult>, QNapi::Object>(
                            resultArray,
                            [&](QNapi::Object &&discoveryResultObject) {
                                return DiscoveryResult::makeFromOhosDiscoveryResultObject(
                                    cbInfo.jsState(), std::move(discoveryResultObject));
                            });
 
                    selfRef.visitInQtThreadIfAlive(
                        [discoveredDevices = std::move(discoveredDevices)](auto &self) {
                            Q_EMIT self.bluetoothDevicesFound(discoveredDevices);
                        });
                },
                {
                    .optOnCallExceptionHandler = [](const Napi::Error &error) {
                        if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
                            qOhosPrintfWarning(
                                "%s: cannot register the discovery result consumer, error code: %u",
                                Q_FUNC_INFO, qToUnderlying(*optErrorCode));
                        }
                    },
                });
 
            if (!discoveredDevicesConsumerHandle)
                return {};
 
            return QtOhos::makeProxyWithJsThreadDeleter(
                std::move(discoveredDevicesConsumerHandle));
        },
        Q_FUNC_INFO);
 
    return m_discoveredDevicesConsumerHandle != nullptr;
}
 
std::optional<bool> QOhosBluetoothDeviceDiscoveryAgentProxy::tryCheckBluetoothDiscovering()
{
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
        return std::nullopt;
 
    return QOhosJsThreadGateway::eval(tryReadBluetoothDiscoveringState, Q_FUNC_INFO);
}
 
void QOhosBluetoothDeviceDiscoveryAgentProxy::resetDiscoveryTracking()
{
    m_discoveryStoppedPollTimer.stop();
    m_discoveryStoppedTimeoutTimer.stop();
    m_discoveryStartedByProxy = false;
}
 
bool QOhosBluetoothDeviceDiscoveryAgentProxy::isForeignDiscoveryOngoing()
{
    return !m_discoveryStartedByProxy && tryCheckBluetoothDiscovering().value_or(false);
}
 
void QOhosBluetoothDeviceDiscoveryAgentProxy::startBluetoothDiscovery()
{
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
        Q_EMIT missingPermission();
        return;
    }
 
    if (!ensureDiscoveredDevicesConsumerRegistered()) {
        qCCritical(
            QT_BT_OHOS,
            "%s: discovery result consumer not registered. Found devices would not be reported.",
            Q_FUNC_INFO);
        Q_EMIT discoveryStartFailed();
        return;
    }
 
    const auto discoveryOngoing = QOhosJsThreadGateway::eval(
        [](QOhosJsState &jsState) {
            const auto optDiscovering = tryReadBluetoothDiscoveringState(jsState);
            if (optDiscovering && *optDiscovering)
                return true;
 
            try {
                jsState.eval("@ohos.bluetooth.connection.startBluetoothDiscovery()");
            } catch (const Napi::Error &error) {
                if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
                    qOhosPrintfWarning(
                        "%s: cannot start the bluetooth discovery, error code: %u", Q_FUNC_INFO,
                        qToUnderlying(*optErrorCode));
                }
                return false;
            }
 
            return true;
        },
        Q_FUNC_INFO);
 
    if (!discoveryOngoing) {
        Q_EMIT discoveryStartFailed();
        return;
    }
 
    m_discoveryStartedByProxy = true;
    m_discoveryStoppedTimeoutTimer.stop();
    m_discoveryStoppedPollTimer.start();
}
 
void QOhosBluetoothDeviceDiscoveryAgentProxy::stopBluetoothDiscovery()
{
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
        Q_EMIT missingPermission();
        return;
    }
 
    if (!QOhosJsThreadGateway::eval(requestBluetoothDiscoveryStop, Q_FUNC_INFO)) {
        Q_EMIT discoveryStopFailed();
        return;
    }
 
    m_discoveryStoppedPollTimer.start();
    m_discoveryStoppedTimeoutTimer.start();
}
 
std::vector<DiscoveryResult> QOhosBluetoothDeviceDiscoveryAgentProxy::getPairedDevices()
{
    if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
        return {};
 
    return QOhosJsThreadGateway::eval(readPairedDevices, Q_FUNC_INFO);
}
 
}
 
QT_END_NAMESPACE
 
#include "moc_qohosbluetoothdevicediscovery_p.cpp"