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 "qohosbluetoothlocaldevice_p.h"
++
++ #include <QtBluetooth/private/qohosbluetoothcommon_p.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 <memory>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QtOhosBluetooth {
++
++ namespace {
++
++ constexpr int permanentlyDiscoverableDuration = 0;
++
++ template<typename T>
++ QOhosSupplier<T> makeQOhosLazySupplier(
++ T fallbackValue, QOhosSupplier<std::optional<QOhosSupplier<T>>> supplierFactory)
++ {
++ struct Context
++ {
++ QOhosSupplier<T> supplier;
++ QOhosSupplier<std::optional<QOhosSupplier<T>>> optSupplierFactory;
++ };
++
++ auto context = std::make_shared<Context>();
++ if (auto optSupplier = supplierFactory()) {
++ context->supplier = std::move(*optSupplier);
++ } else {
++ context->supplier = [fallbackValue = std::move(fallbackValue)]() { return fallbackValue; };
++ context->optSupplierFactory = std::move(supplierFactory);
++ }
++
++ return [context]() {
++ if (context->optSupplierFactory) {
++ if (auto optSupplier = context->optSupplierFactory()) {
++ context->supplier = std::move(*optSupplier);
++ context->optSupplierFactory = nullptr;
++ }
++ }
++
++ return context->supplier();
++ };
++ }
++
++ std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode> readScanMode(QOhosJsState &jsState)
++ {
++ if (!isBluetoothEnabled(jsState))
++ return std::nullopt;
++
++ try {
++ return jsState.tryMapOhosEnumFromJs<QOhosBluetoothLocalDeviceProxy::ScanMode>(
++ jsState.eval<QNapi::Number>("@ohos.bluetooth.connection.getBluetoothScanMode()"));
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot read the bluetooth scan mode, error code: %u", Q_FUNC_INFO, qToUnderlying(*optErrorCode));
++ }
++ return std::nullopt;
++ }
++ }
++
++ std::shared_ptr<void> registerScanModeChangeConsumer(
++ QOhosJsState &jsState,
++ QOhosConsumer<std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode>> scanModeChangeConsumer)
++ {
++ auto sharedScanModeChangeConsumer = QtOhos::moveToSharedPtr(std::move(scanModeChangeConsumer));
++
++ auto connectionModule = jsState.eval<QNapi::Object>("@ohos.bluetooth.connection");
++
++ auto scanModeChangeHandlerRef = QtOhos::moveToSharedPtr(
++ QNapi::Reference<>::makePersistentFrom(
++ QNapi::Function::New(
++ jsState.env(),
++ [weakScanModeChangeConsumer = QtOhos::makeWeakPtr(sharedScanModeChangeConsumer)](const QOhosCallbackInfo &cbInfo) {
++ auto scanModeChangeConsumer = weakScanModeChangeConsumer.lock();
++ if (!scanModeChangeConsumer) {
++ qOhosPrintfWarning(
++ "%s: got unexpected scan mode change callback call for detached handler",
++ Q_FUNC_INFO);
++ return cbInfo.Env().Undefined();
++ }
++
++ auto ohosScanMode = cbInfo.getFirstArg<QNapi::Number>(Q_FUNC_INFO);
++ (*scanModeChangeConsumer)(
++ cbInfo.jsState().tryMapOhosEnumFromJs<QOhosBluetoothLocalDeviceProxy::ScanMode>(ohosScanMode));
++
++ return cbInfo.Env().Undefined();
++ })));
++
++ try {
++ connectionModule.eval("onScanModeChange(*)", {scanModeChangeHandlerRef->Value()});
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot register the scan mode change consumer, error code: %u", Q_FUNC_INFO,
++ qToUnderlying(*optErrorCode));
++ }
++ return {};
++ }
++
++ return QtOhos::makeDestroyNotifier(
++ [sharedScanModeChangeConsumer, scanModeChangeHandlerRef,
++ connectionModuleWeakRef = QtOhos::moveToSharedPtr(Napi::Weak(connectionModule))]() {
++ auto connectionModuleValue = connectionModuleWeakRef->Value();
++ if (!connectionModuleValue.IsObject()) {
++ qOhosPrintfDebug(
++ "%s: not unregistering the scan mode change consumer, the module is not alive anymore",
++ Q_FUNC_INFO);
++ return;
++ }
++
++ try {
++ QNapi::checkedCast<QNapi::Object>(connectionModuleValue).eval(
++ "offScanModeChange(*)", {scanModeChangeHandlerRef->Value()});
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot unregister the scan mode change consumer, error code: %u",
++ Q_FUNC_INFO, qToUnderlying(*optErrorCode));
++ }
++ }
++ });
++ }
++
++ QOhosSupplier<std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode>> makeScanModeSupplier(
++ QOhosConsumer<std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode>> optScanModeChangeConsumer)
++ {
++ bool scanModeChangeEventRegistered = false;
++
++ auto cachedScanModeSupplier =
++ makeQOhosDataSource<std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode>>(
++ readScanMode,
++ [&](QOhosJsState &jsState,
++ QOhosConsumer<std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode>> scanModeChangeConsumer) {
++ auto scanModeChangeConsumerHandle =
++ registerScanModeChangeConsumer(jsState, std::move(scanModeChangeConsumer));
++ scanModeChangeEventRegistered = scanModeChangeConsumerHandle != nullptr;
++
++ return scanModeChangeConsumerHandle;
++ },
++ std::move(optScanModeChangeConsumer),
++ QtOhos::invokeInQtThread,
++ Q_FUNC_INFO);
++
++ return [scanModeChangeEventRegistered, cachedScanModeSupplier = std::move(cachedScanModeSupplier)]()
++ -> std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode> {
++ if (scanModeChangeEventRegistered) {
++ if (const auto optCachedScanMode = cachedScanModeSupplier())
++ return optCachedScanMode;
++ }
++
++ return QOhosJsThreadGateway::eval(readScanMode, Q_FUNC_INFO);
++ };
++ }
++
++ }
++
++ QOhosBluetoothLocalDeviceProxy::QOhosBluetoothLocalDeviceProxy()
++ : m_scanModeSupplier(
++ makeQOhosLazySupplier<std::optional<ScanMode>>(
++ std::nullopt,
++ [this]() -> std::optional<QOhosSupplier<std::optional<ScanMode>>> {
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
++ return std::nullopt;
++
++ return makeScanModeSupplier(
++ [this](auto optScanMode) {
++ if (optScanMode)
++ Q_EMIT scanModeChanged(*optScanMode);
++ });
++ }))
++ {
++ }
++
++ std::shared_ptr<QOhosBluetoothLocalDeviceProxy> QOhosBluetoothLocalDeviceProxy::instance()
++ {
++ static auto instance = std::shared_ptr<QOhosBluetoothLocalDeviceProxy>(new QOhosBluetoothLocalDeviceProxy());
++ return instance;
++ }
++
++ std::optional<QString> QOhosBluetoothLocalDeviceProxy::tryGetLocalDeviceName() const
++ {
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO))
++ return std::nullopt;
++
++ return QOhosJsThreadGateway::eval(
++ [](QOhosJsState &jsState) -> std::optional<QString> {
++ if (!isBluetoothEnabled(jsState))
++ return std::nullopt;
++
++ try {
++ return QString::fromStdString(
++ jsState.eval<QNapi::String>("@ohos.bluetooth.connection.getLocalName()").Utf8Value());
++ } catch (const Napi::Error &error) {
++ if (const auto optErrorCode = tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO)) {
++ qOhosPrintfWarning(
++ "%s: cannot read the local device name, error code: %u", Q_FUNC_INFO,
++ qToUnderlying(*optErrorCode));
++ }
++ return std::nullopt;
++ }
++ });
++ }
++
++ std::optional<QOhosBluetoothLocalDeviceProxy::ScanMode> QOhosBluetoothLocalDeviceProxy::tryGetScanMode()
++ {
++ return m_scanModeSupplier();
++ }
++
++ std::optional<QOhosBluetoothErrorCode> QOhosBluetoothLocalDeviceProxy::trySetBluetoothScanMode(
++ QOhosBluetoothLocalDeviceProxy::ScanMode scanMode)
++ {
++ if (!checkAccessBluetoothPermissionGranted(Q_FUNC_INFO)) {
++ Q_EMIT missingPermission();
++ return QOhosBluetoothErrorCode::PermissionDenied;
++ }
++
++ const auto optErrorCode = QOhosJsThreadGateway::eval(
++ [&](QOhosJsState &jsState) -> std::optional<QOhosBluetoothErrorCode> {
++ if (!isBluetoothEnabled(jsState))
++ return QOhosBluetoothErrorCode::BluetoothDisabled;
++
++ try {
++ jsState.eval(
++ "@ohos.bluetooth.connection.setBluetoothScanMode(*)",
++ {
++ jsState.mapOhosEnumToJs(scanMode),
++ permanentlyDiscoverableDuration,
++ });
++ return std::nullopt;
++ } catch (const Napi::Error &error) {
++ return tryGetKnownErrorCode(error.Value(), Q_FUNC_INFO);
++ }
++ });
++
++ if (optErrorCode == QOhosBluetoothErrorCode::PermissionDenied) {
++ Q_EMIT missingPermission();
++ }
++
++ return optErrorCode;
++ }
++
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qohosbluetoothlocaldevice_p.cpp"