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 "qohosbluetoothremotedevice_p.h"
++
++ #include <QtBluetooth/private/qohosbluetoothcommon_p.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 <optional>
++ #include <string>
++ #include <vector>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_DECLARE_LOGGING_CATEGORY(QT_BT_OHOS)
++
++ namespace QtOhosBluetooth {
++
++ namespace {
++
++ std::shared_ptr<void> registerBondStateChangeConsumer(
++ QOhosJsState &jsState,
++ QOhosConsumer<std::string, std::optional<QOhosBluetoothRemoteDeviceProxy::BondState>, std::optional<QOhosBluetoothRemoteDeviceProxy::UnbondCause>> bondStateChangeConsumer)
++ {
++ return registerQOhosOnOffMethodsBasedEventHandler(
++ jsState.eval<QNapi::Object>("@ohos.bluetooth.connection"), "bondStateChange",
++ [bondStateChangeConsumer = std::move(bondStateChangeConsumer)](const QOhosCallbackInfo &cbInfo) {
++ auto bondStateObject = cbInfo.getFirstArg<QNapi::Object>(Q_FUNC_INFO);
++
++ auto deviceId = bondStateObject.get<QNapi::String>("deviceId").Utf8Value();
++ const auto optBondState = cbInfo.jsState().tryMapOhosEnumFromJs<QOhosBluetoothRemoteDeviceProxy::BondState>(
++ bondStateObject.get<QNapi::Number>("state"));
++ const auto unbondCauseValue =
++ QNapi::getOptionalPropOrEmpty<QNapi::Number>(bondStateObject, "cause");
++ const auto optUnbondCause = unbondCauseValue.IsEmpty()
++ ? std::optional<QOhosBluetoothRemoteDeviceProxy::UnbondCause>()
++ : cbInfo.jsState().tryMapOhosEnumFromJs<QOhosBluetoothRemoteDeviceProxy::UnbondCause>(
++ unbondCauseValue);
++
++ bondStateChangeConsumer(deviceId, optBondState, optUnbondCause);
++ },
++ {
++ .optOnCallExceptionHandler = [](const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot register the bond state change consumer, error code: %u",
++ Q_FUNC_INFO, qToUnderlying(*optErrorCode));
++ }
++ },
++ });
++ }
++
++ std::optional<QOhosBluetoothRemoteDeviceProxy::BondState> readPairState(
++ QOhosJsState &jsState, const std::string &deviceId)
++ {
++ if (!isBluetoothEnabled(jsState))
++ return std::nullopt;
++
++ try {
++ return jsState.tryMapOhosEnumFromJs<QOhosBluetoothRemoteDeviceProxy::BondState>(
++ jsState.eval<QNapi::Number>(
++ "@ohos.bluetooth.connection.getPairState(*)", {deviceId}));
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot read the pair state of the device %s, error code: %u", Q_FUNC_INFO,
++ deviceId.c_str(), qToUnderlying(*optErrorCode));
++ }
++ return std::nullopt;
++ }
++ }
++
++ }
++
++ std::optional<std::string> readRemoteDeviceName(QOhosJsState &jsState, const std::string &deviceId)
++ {
++ try {
++ return jsState.eval<QNapi::String>(
++ "@ohos.bluetooth.connection.getRemoteDeviceName(*)", {deviceId}).Utf8Value();
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot read the name of the device %s, error code: %u", Q_FUNC_INFO,
++ deviceId.c_str(), qToUnderlying(*optErrorCode));
++ }
++ return std::nullopt;
++ }
++ }
++
++ std::optional<quint32> readRemoteDeviceClass(QOhosJsState &jsState, const std::string &deviceId)
++ {
++ try {
++ return jsState.eval<QNapi::Object>(
++ "@ohos.bluetooth.connection.getRemoteDeviceClass(*)", {deviceId})
++ .get<QNapi::Number>("classOfDevice").Uint32Value();
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot read the class of the device %s, error code: %u", Q_FUNC_INFO,
++ deviceId.c_str(), qToUnderlying(*optErrorCode));
++ }
++ return std::nullopt;
++ }
++ }
++
++ std::optional<QOhosBluetoothRemoteDeviceProxy::BluetoothTransport> readRemoteDeviceTransport(
++ QOhosJsState &jsState, const std::string &deviceId)
++ {
++ try {
++ return jsState.tryMapOhosEnumFromJs<QOhosBluetoothRemoteDeviceProxy::BluetoothTransport>(
++ jsState.eval<QNapi::Number>(
++ "@ohos.bluetooth.connection.getRemoteDeviceTransport(*)", {deviceId}));
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot read the transport of the device %s, error code: %u", Q_FUNC_INFO,
++ deviceId.c_str(), qToUnderlying(*optErrorCode));
++ }
++ return std::nullopt;
++ }
++ }
++
++ bool isRemoteDeviceLowEnergyOnly(QOhosJsState &jsState, const std::string &deviceId)
++ {
++ return readRemoteDeviceTransport(jsState, deviceId)
++ == QOhosBluetoothRemoteDeviceProxy::BluetoothTransport::TRANSPORT_LE;
++ }
++
++ QOhosBluetoothRemoteDeviceProxy::QOhosBluetoothRemoteDeviceProxy()
++ {
++ ensureBondStateChangeConsumerRegistered();
++ }
++
++ bool QOhosBluetoothRemoteDeviceProxy::ensureBondStateChangeConsumerRegistered()
++ {
++ if (m_bondStateChangeConsumerHandle)
++ return true;
++
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
++ return false;
++
++ auto selfRef = QtOhos::makeQThreadSafeRef(this);
++ m_bondStateChangeConsumerHandle = QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) -> std::shared_ptr<void> {
++ auto bondStateChangeConsumerHandle = registerBondStateChangeConsumer(
++ jsState,
++ [selfRef](std::string deviceId, std::optional<BondState> optBondState, std::optional<UnbondCause> optUnbondCause) {
++ if (!optBondState)
++ return;
++
++ selfRef.visitInQtThreadIfAlive(
++ [deviceId = QString::fromStdString(deviceId), bondState = *optBondState, optUnbondCause](auto &self) {
++ Q_EMIT self.bondStateChanged(deviceId, bondState, optUnbondCause);
++ });
++ });
++
++ if (!bondStateChangeConsumerHandle)
++ return {};
++
++ return QtOhos::makeProxyWithJsThreadDeleter(std::move(bondStateChangeConsumerHandle));
++ },
++ Q_FUNC_INFO);
++
++ return m_bondStateChangeConsumerHandle != nullptr;
++ }
++
++ std::shared_ptr<QOhosBluetoothRemoteDeviceProxy> QOhosBluetoothRemoteDeviceProxy::instance()
++ {
++ static std::weak_ptr<QOhosBluetoothRemoteDeviceProxy> weakInstance;
++
++ auto instance = weakInstance.lock();
++ if (!instance) {
++ instance = std::shared_ptr<QOhosBluetoothRemoteDeviceProxy>(
++ new QOhosBluetoothRemoteDeviceProxy());
++ weakInstance = instance;
++ }
++
++ return instance;
++ }
++
++ std::optional<QString> QOhosBluetoothRemoteDeviceProxy::tryGetRemoteDeviceName(const QString &deviceId)
++ {
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
++ return std::nullopt;
++
++ return QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) -> std::optional<QString> {
++ if (!isBluetoothEnabled(jsState))
++ return std::nullopt;
++
++ const auto optRemoteDeviceName = readRemoteDeviceName(jsState, deviceId.toStdString());
++
++ return optRemoteDeviceName
++ ? std::optional(QString::fromStdString(*optRemoteDeviceName))
++ : std::nullopt;
++ },
++ Q_FUNC_INFO);
++ }
++
++ std::optional<QOhosBluetoothRemoteDeviceProxy::BondState> QOhosBluetoothRemoteDeviceProxy::tryGetPairState(
++ const QString &deviceId)
++ {
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
++ return std::nullopt;
++
++ return QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) {
++ return readPairState(jsState, deviceId.toStdString());
++ },
++ Q_FUNC_INFO);
++ }
++
++ std::optional<QOhosBluetoothErrorCode> QOhosBluetoothRemoteDeviceProxy::requestRemoteDeviceServices(
++ const QString &deviceId)
++ {
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
++ return QOhosBluetoothErrorCode::PermissionDenied;
++
++ auto selfRef = QtOhos::makeQThreadSafeRef(this);
++ return QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) -> std::optional<QOhosBluetoothErrorCode> {
++ if (!isBluetoothEnabled(jsState))
++ return QOhosBluetoothErrorCode::BluetoothDisabled;
++
++ RemoteDeviceServices remoteDeviceServices;
++ remoteDeviceServices.deviceId = deviceId.toStdString();
++ remoteDeviceServices.optDeviceName =
++ readRemoteDeviceName(jsState, remoteDeviceServices.deviceId);
++ remoteDeviceServices.optClassOfDevice =
++ readRemoteDeviceClass(jsState, remoteDeviceServices.deviceId);
++ remoteDeviceServices.lowEnergyOnly =
++ isRemoteDeviceLowEnergyOnly(jsState, remoteDeviceServices.deviceId);
++
++ auto pendingServices = QtOhos::moveToSharedPtr(std::move(remoteDeviceServices));
++ auto reportRemoteDeviceServices =
++ [selfRef, pendingServices]() {
++ selfRef.visitInQtThreadIfAlive(
++ [pendingServices](auto &self) {
++ Q_EMIT self.remoteDeviceServicesRead(*pendingServices);
++ });
++ };
++
++ try {
++ jsState.evalToPromiseOrRejectOnThrow(
++ "@ohos.bluetooth.connection.getRemoteProfileUuids(*)",
++ {pendingServices->deviceId})
++ .onThen(
++ [reportRemoteDeviceServices, pendingServices](
++ const QOhosCallbackInfo &cbInfo) {
++ auto resultArray = cbInfo.getFirstArg<QNapi::Array>(Q_FUNC_INFO);
++ pendingServices->optProfileUuids =
++ QNapi::getArrayElements<std::vector<std::string>, QNapi::String>(
++ resultArray,
++ [](QNapi::String &&profileUuid) {
++ return profileUuid.Utf8Value();
++ });
++ reportRemoteDeviceServices();
++ },
++ [reportRemoteDeviceServices](const QOhosCallbackInfo &cbInfo) {
++ QtOhos::logJsCallbackError(cbInfo, "Got error from getRemoteProfileUuids()");
++ reportRemoteDeviceServices();
++ });
++ return std::nullopt;
++ } catch (const Napi::Error &error) {
++ const auto errorCode =
++ tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)
++ .value_or(QOhosBluetoothErrorCode::OperationFailed);
++ qOhosPrintfWarning(
++ "%s: cannot read the remote profile uuids, error code: %u", Q_FUNC_INFO,
++ qToUnderlying(errorCode));
++ return errorCode;
++ }
++ },
++ Q_FUNC_INFO);
++ }
++
++ bool QOhosBluetoothRemoteDeviceProxy::pairDevice(const QString &deviceId)
++ {
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
++ Q_EMIT missingPermission();
++ return false;
++ }
++
++ if (!ensureBondStateChangeConsumerRegistered()) {
++ qCCritical(
++ QT_BT_OHOS,
++ "%s: bond state change consumer not registered. Pairing result will not be reported.",
++ Q_FUNC_INFO);
++ }
++
++ auto selfRef = QtOhos::makeQThreadSafeRef(this);
++ const auto optErrorCode = QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) -> std::optional<QOhosBluetoothErrorCode> {
++ try {
++ jsState.evalToPromiseOrRejectOnThrow(
++ "@ohos.bluetooth.connection.pairDevice(*)", {deviceId.toStdString()})
++ .onCatch(
++ [selfRef, pairedDeviceId = deviceId.toStdString()](
++ const QOhosCallbackInfo &cbInfo) {
++ QtOhos::logJsCallbackError(cbInfo, "Got error from pairDevice()");
++ selfRef.visitInQtThreadIfAlive(
++ [pairedDeviceId](auto &self) {
++ Q_EMIT self.pairDeviceFailed(QString::fromStdString(pairedDeviceId));
++ });
++ });
++ return std::nullopt;
++ } catch (const Napi::Error &error) {
++ return tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO);
++ }
++ },
++ Q_FUNC_INFO);
++
++ if (!optErrorCode)
++ return true;
++
++ qCWarning(
++ QT_BT_OHOS, "%s: cannot start pairing with the device %ls, error code: %u", Q_FUNC_INFO,
++ qUtf16Printable(deviceId), qToUnderlying(*optErrorCode));
++
++ return false;
++ }
++
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qohosbluetoothremotedevice_p.cpp"