simplejsble 0.0.4 → 0.0.6

package/simpleble/src/backends/windows/PeripheralWindows.h

@@ -0,0 +1,129 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Service.h>
+#include <simpleble/Types.h>
+
+#include "AdapterBaseTypes.h"
+#include "PeripheralBase.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include "winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h"
+#include "winrt/Windows.Devices.Bluetooth.h"
+
+#include <condition_variable>
+#include <functional>
+#include <map>
+#include <memory>
+
+using namespace winrt::Windows::Devices::Bluetooth;
+using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;
+
+namespace SimpleBLE {
+
+struct gatt_descriptor_t {
+    GattDescriptor obj = nullptr;
+};
+
+struct gatt_characteristic_t {
+    GattCharacteristic obj = nullptr;
+    winrt::event_token value_changed_token;
+    std::function<void(const GattCharacteristic& sender, const GattValueChangedEventArgs& args)> value_changed_callback;
+    std::map<BluetoothUUID, gatt_descriptor_t> descriptors;
+};
+
+struct gatt_service_t {
+    GattDeviceService obj = nullptr;
+    std::map<BluetoothUUID, gatt_characteristic_t> characteristics;
+};
+
+class PeripheralWindows : public PeripheralBase {
+  public:
+    PeripheralWindows(BluetoothLEDevice device);
+    PeripheralWindows(advertising_data_t advertising_data);
+    virtual ~PeripheralWindows();
+
+    virtual void* underlying() const override;
+
+    virtual std::string identifier() override;
+    virtual BluetoothAddress address() override;
+    virtual SimpleBLE::BluetoothAddressType address_type() override;
+    virtual int16_t rssi() override;
+    virtual int16_t tx_power() override;
+    virtual uint16_t mtu() override;
+
+    virtual void connect() override;
+    virtual void disconnect() override;
+    virtual bool is_connected() override;
+    virtual bool is_connectable() override;
+    virtual bool is_paired() override;
+    virtual void unpair() override;
+
+    virtual std::vector<std::shared_ptr<ServiceBase>> available_services() override;
+    virtual std::vector<std::shared_ptr<ServiceBase>> advertised_services() override;
+    virtual std::map<uint16_t, ByteArray> manufacturer_data() override;
+
+    // clang-format off
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic) override;
+    virtual void write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) override;
+    virtual void write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) override;
+    virtual void notify(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) override;
+    virtual void indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) override;
+    virtual void unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) override;
+
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor) override;
+    virtual void write(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor, ByteArray const& data) override;
+    // clang-format on
+
+    virtual void set_callback_on_connected(std::function<void()> on_connected) override;
+    virtual void set_callback_on_disconnected(std::function<void()> on_disconnected) override;
+
+    // Internal methods not exposed to the user.
+
+    void update_advertising_data(advertising_data_t advertising_data);
+
+  private:
+    BluetoothLEDevice device_{nullptr};
+
+    // NOTE: Calling device_.Name() or device_.BluetoothAddress() might
+    // cause a crash on some devices.
+    // This is because any operation on the object before it is connected will
+    // initiate a connection, which can then cause further cascading failures.
+    // See:
+    // https://docs.microsoft.com/en-us/uwp/api/windows.devices.bluetooth.bluetoothledevice.frombluetoothaddressasync
+
+    std::string identifier_;
+    BluetoothAddress address_;
+    SimpleBLE::BluetoothAddressType address_type_;
+    int16_t rssi_ = INT16_MIN;
+    int16_t tx_power_ = INT16_MIN;
+    uint16_t mtu_;
+    bool connectable_;
+    winrt::event_token connection_status_changed_token_;
+
+    std::condition_variable disconnection_cv_;
+    std::mutex disconnection_mutex_;
+
+    std::map<BluetoothUUID, gatt_service_t> gatt_map_;
+
+    kvn::safe_callback<void()> callback_on_connected_;
+    kvn::safe_callback<void()> callback_on_disconnected_;
+
+    std::map<uint16_t, SimpleBLE::ByteArray> manufacturer_data_;
+    std::map<BluetoothUUID, SimpleBLE::ByteArray> service_data_;
+
+    bool _attempt_connect();
+
+    gatt_characteristic_t& _fetch_characteristic(const BluetoothUUID& service_uuid,
+                                                 const BluetoothUUID& characteristic_uuid);
+
+    GattDescriptor _fetch_descriptor(const BluetoothUUID& service_uuid, const BluetoothUUID& characteristic_uuid,
+                                     const BluetoothUUID& descriptor_uuid);
+
+    void _subscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                    std::function<void(ByteArray payload)> callback, GattCharacteristicProperties property,
+                    GattClientCharacteristicConfigurationDescriptorValue descriptor_value);
+};
+
+}  // namespace SimpleBLE

package/simpleble/src/backends/windows/Utils.cpp

@@ -0,0 +1,146 @@
+#include "Utils.h"
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+#include <roapi.h>
+#include <sdkddkver.h>
+
+#include "LoggingInternal.h"
+
+#if WDK_NTDDI_VERSION < NTDDI_WIN10_VB
+#error "Windows SDK version before 10.0.19041.0 is not supported"
+#elif WDK_NTDDI_VERSION == NTDDI_WIN10_VB
+// For Windows SDK version before 10.0.19041.0, remap functions to post-10.0.19041.0 versions
+#define WINRT_IMPL_CoGetApartmentType WINRT_CoGetApartmentType
+#endif
+
+#define MAC_ADDRESS_STR_LENGTH (size_t)17  // Two chars per byte, 5 chars for colon
+
+namespace SimpleBLE {
+
+void initialize_winrt() {
+    static bool initialized = false;
+    if (initialized) return;
+    initialized = true;
+
+    int32_t cotype = APTTYPE_NA;
+    int32_t qualifier = APTTYPEQUALIFIER_NONE;
+    winrt::hresult get_apartment_result = WINRT_IMPL_CoGetApartmentType(&cotype, &qualifier);
+
+    SIMPLEBLE_LOG_DEBUG(fmt::format("CoGetApartmentType: cotype={}, qualifier={}, result={:X}", cotype, qualifier,
+                                    (uint32_t)get_apartment_result));
+
+    if (cotype == APTTYPE_STA || cotype == APTTYPE_MAINSTA) {
+        SIMPLEBLE_LOG_WARN("Single-threaded apartment detected, uninitializing.");
+        RoUninitialize();
+    }
+
+    winrt::hresult result = RoInitialize(RO_INIT_MULTITHREADED);
+    std::string result_str = hresult_to_string(result);
+    if (FAILED(result)) {
+        SIMPLEBLE_LOG_ERROR(fmt::format("RoInitialize failed: {}", result_str));
+    }
+}
+
+std::string _mac_address_to_str(uint64_t mac_address) {
+    uint8_t* mac_ptr = (uint8_t*)&mac_address;
+    char mac_str[MAC_ADDRESS_STR_LENGTH + 1] = {0};  // Include null terminator.
+
+    snprintf(mac_str, MAC_ADDRESS_STR_LENGTH + 1, "%02x:%02x:%02x:%02x:%02x:%02x", mac_ptr[5], mac_ptr[4], mac_ptr[3],
+             mac_ptr[2], mac_ptr[1], mac_ptr[0]);
+    return std::string(mac_str);
+}
+
+uint64_t _str_to_mac_address(std::string mac_str) {
+    // TODO: Validate input - Expected Format: XX:XX:XX:XX:XX:XX
+    uint64_t mac_address_number = 0;
+    uint8_t* mac_ptr = (uint8_t*)&mac_address_number;
+    sscanf(mac_str.c_str(), "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx", &mac_ptr[5], &mac_ptr[4], &mac_ptr[3],
+           &mac_ptr[2], &mac_ptr[1], &mac_ptr[0]);
+    return mac_address_number;
+}
+
+winrt::guid uuid_to_guid(const std::string& uuid) {
+    // TODO: Add proper cleanup / validation
+    std::stringstream helper;
+    for (int i = 0; i < uuid.length(); i++) {
+        if (uuid[i] != '-') {
+            helper << uuid[i];
+        }
+    }
+    std::string clean_uuid = helper.str();
+    winrt::guid guid;
+    uint64_t* data4_ptr = (uint64_t*)guid.Data4;
+
+    guid.Data1 = static_cast<uint32_t>(std::strtoul(clean_uuid.substr(0, 8).c_str(), nullptr, 16));
+    guid.Data2 = static_cast<uint16_t>(std::strtoul(clean_uuid.substr(8, 4).c_str(), nullptr, 16));
+    guid.Data3 = static_cast<uint16_t>(std::strtoul(clean_uuid.substr(12, 4).c_str(), nullptr, 16));
+    *data4_ptr = _byteswap_uint64(std::strtoull(clean_uuid.substr(16, 16).c_str(), nullptr, 16));
+
+    return guid;
+}
+
+std::string guid_to_uuid(const winrt::guid& guid) {
+    std::stringstream helper;
+    // TODO: It might be cleaner to use snprintf instead of string streams.
+
+    for (uint32_t i = 0; i < 4; i++) {
+        // * NOTE: We're performing a byte swap!
+        helper << std::hex << std::setw(2) << std::setfill('0') << (int)((uint8_t*)&guid.Data1)[3 - i];
+    }
+    helper << '-';
+    for (uint32_t i = 0; i < 2; i++) {
+        // * NOTE: We're performing a byte swap!
+        helper << std::hex << std::setw(2) << std::setfill('0') << (int)((uint8_t*)&guid.Data2)[1 - i];
+    }
+    helper << '-';
+    for (uint32_t i = 0; i < 2; i++) {
+        // * NOTE: We're performing a byte swap!
+        helper << std::hex << std::setw(2) << std::setfill('0') << (int)((uint8_t*)&guid.Data3)[1 - i];
+    }
+    helper << '-';
+    for (uint32_t i = 0; i < 2; i++) {
+        helper << std::hex << std::setw(2) << std::setfill('0') << (int)guid.Data4[i];
+    }
+    helper << '-';
+    for (uint32_t i = 0; i < 6; i++) {
+        helper << std::hex << std::setw(2) << std::setfill('0') << (int)guid.Data4[2 + i];
+    }
+    return helper.str();
+}
+
+ByteArray ibuffer_to_bytearray(const IBuffer& buffer) { return ByteArray((const char*)buffer.data(), buffer.Length()); }
+
+IBuffer bytearray_to_ibuffer(const ByteArray& array) {
+    DataWriter writer;
+    for (auto& byte : array) {
+        writer.WriteByte(byte);
+    }
+    return writer.DetachBuffer();
+}
+
+std::string hresult_to_string(winrt::hresult hr) {
+    if (SUCCEEDED(hr)) {
+        if (hr == S_OK) return "S_OK";
+        if (hr == S_FALSE) return "S_FALSE";
+        // Other success codes are possible but less common here.
+        return fmt::format("Success ({:#08x})", (uint32_t)hr);
+    } else {
+        try {
+            // Attempt to get the system message for the error.
+            winrt::check_hresult(hr);
+        } catch (const winrt::hresult_error& e) {
+            // Use fmt::format for consistent formatting
+            return fmt::format("Error ({:#08x}): {}", (uint32_t)hr, winrt::to_string(e.message()));
+        } catch (...) {
+            // Fallback for unexpected exceptions during error handling
+            return fmt::format("Unknown Error ({:#08x})", (uint32_t)hr);
+        }
+        // Should not be reached if hr is an error and check_hresult behaved as expected
+        return fmt::format("Error ({:#08x})", (uint32_t)hr);
+    }
+}
+
+}  // namespace SimpleBLE

package/simpleble/src/backends/windows/Utils.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <cstdint>
+#include <exception>
+#include <string>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include "winrt/Windows.Foundation.h"
+#include "winrt/Windows.Storage.Streams.h"
+#include "winrt/base.h"
+
+using namespace winrt::Windows;
+using namespace winrt::Windows::Storage::Streams;
+
+constexpr uint32_t TEN_SECONDS_IN_MSECS = 10000;
+
+namespace SimpleBLE {
+void initialize_winrt();
+
+std::string _mac_address_to_str(uint64_t mac_address);
+uint64_t _str_to_mac_address(std::string mac_address);
+
+winrt::guid uuid_to_guid(const std::string& uuid);
+std::string guid_to_uuid(const winrt::guid& guid);
+
+ByteArray ibuffer_to_bytearray(const IBuffer& buffer);
+IBuffer bytearray_to_ibuffer(const ByteArray& array);
+
+std::string hresult_to_string(winrt::hresult hr);
+
+template <typename async_t>
+static auto async_get(async_t const& async) {
+    if (async.Status() == Foundation::AsyncStatus::Started) {
+        wait_for_completed(async, TEN_SECONDS_IN_MSECS);
+    }
+    try {
+        return async.GetResults();
+    } catch (const winrt::hresult_error& err) {
+        throw SimpleBLE::Exception::WinRTException(err.code().value, winrt::to_string(err.message()));
+    } catch (const std::exception& err) {
+        throw SimpleBLE::Exception::BaseException(err.what());
+    }
+}
+
+}  // namespace SimpleBLE

package/simpleble/src/builders/BuildVec.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "BuilderBase.h"
+
+namespace SimpleBLE::Factory {
+
+template <typename V1>
+struct BuildVecDeduce {
+    template <typename T>
+    operator T() && {
+        T vec;
+        vec.reserve(objs.size());
+        for (auto& obj : objs) {
+            vec.push_back(build(std::move(obj)));
+        }
+        return vec;
+    }
+
+    V1 objs;
+};
+
+/**
+ * Build a vector of objects which are not directly constructible.
+ *
+ * This calls `Factory::build()` for each object in the input vector.
+ */
+template <typename V1>
+auto vector(V1 objs) {
+    return BuildVecDeduce<V1>{std::move(objs)};
+}
+
+}  // namespace SimpleBLE::Factory

package/simpleble/src/builders/BuilderBase.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace SimpleBLE::Factory {
+
+/**
+ * Generic builder class for PIMP classes that have an "internal_" member variable.
+ *
+ * Normally, the base class's non-default constructor will not exist or will be
+ * protected, so that the user cannot directly initialize the class (i.e. set
+ * the "internal_" member variable to non-null).
+ *
+ * Additionally, this builder class allows for the construction of pointer-to
+ * object directly in the constructor.
+ *
+ * It is possible to specialize this class for classes that are constructed
+ * differently.
+ */
+template <typename T>
+struct Builder : public T {
+    using T::internal_;
+    using PtrT = decltype(Builder::internal_);
+
+    Builder() { this->internal_ = std::make_shared<InternalT>(); }
+    using InternalT = typename std::remove_reference<decltype(*(Builder::internal_))>::type;
+
+    Builder(PtrT&& internal) { this->internal_ = std::move(internal); }
+
+    template <typename dPtr>
+    Builder(dPtr&& internal) {
+        this->internal_ = internal;
+    }
+
+    template <typename... ARG>
+    Builder(ARG&&... args) {
+        using InternalT = typename std::remove_reference<decltype(*(Builder::internal_))>::type;
+        this->internal_ = std::make_shared<InternalT>(std::forward<ARG>(args)...);
+    }
+};
+
+/**
+ * Helper class to deduce the return type of the build function.
+ */
+template <typename ARG>
+struct BuildDeduce {
+    template <typename T>
+    operator T() && {
+        return Builder<T>(std::move(arg));
+    }
+
+    ARG arg;
+};
+
+struct BuildDeduce0 {
+    template <typename T>
+    operator T() && {
+        return Builder<T>();
+    }
+};
+
+/**
+ * Build a new object which is not directly constructible.
+ *
+ * The target class must have a default constructor and must have a protected
+ * "internal_" member variable.
+ */
+template <typename ARG>
+auto build(ARG x) {
+    return BuildDeduce<ARG>{std::move(x)};
+}
+
+/**
+ * Build a new object whose "internal_" type can be default-constructed.
+ *
+ * For example, for Adapter, calling `Adapter a = Factory::build();` is equivalent to
+ * `Adapter a = Build<Adapter>(std::make_shared<AdapterBase>());`.
+ */
+template <typename = void>
+auto build() {
+    return BuildDeduce0{};
+}
+
+}  // namespace SimpleBLE::Factory

package/simpleble/src/external/TaskRunner.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <chrono>
+#include <functional>
+#include <future>
+#include <mutex>
+#include <optional>
+#include <queue>
+#include <thread>
+
+class TaskRunner {
+  private:
+    using Clock = std::chrono::steady_clock;
+    using TimePoint = Clock::time_point;
+    using Duration = Clock::duration;
+    using Task = std::function<std::optional<Duration>()>;
+
+    struct ScheduledTask {
+        TimePoint executionTime;
+        Task task;
+
+        bool operator>(const ScheduledTask& other) const { return executionTime > other.executionTime; }
+    };
+
+    std::priority_queue<ScheduledTask, std::vector<ScheduledTask>, std::greater<ScheduledTask>> taskQueue;
+    std::mutex taskQueueMutex;
+    std::condition_variable taskQueueCV;
+    bool running = false;
+    std::thread workerThread;
+
+  public:
+    TaskRunner() = default;
+
+    ~TaskRunner() { stop(); }
+
+    void start() {
+        if (!running) {
+            running = true;
+            workerThread = std::thread(&TaskRunner::workerLoop, this);
+        }
+    }
+
+    void stop() {
+        if (running) {
+            {
+                std::unique_lock<std::mutex> lock(taskQueueMutex);
+                running = false;
+                taskQueueCV.notify_one();
+            }
+            workerThread.join();
+        }
+    }
+
+    void dispatch(Task task, Duration delay) {
+        TimePoint executionTime = Clock::now() + delay;
+        {
+            std::unique_lock<std::mutex> lock(taskQueueMutex);
+            taskQueue.push({executionTime, std::move(task)});
+            taskQueueCV.notify_one();
+        }
+        if (!running) {
+            start();
+        }
+    }
+
+  private:
+    void workerLoop() {
+        while (true) {
+            std::unique_lock<std::mutex> lock(taskQueueMutex);
+            taskQueueCV.wait(lock, [this] { return !running || !taskQueue.empty(); });
+
+            if (!running) {
+                break;
+            }
+
+            if (taskQueue.empty()) {
+                continue;
+            }
+
+            // NOTE: If a new task is added to the queue with a shorter delay than the current top task, the worker
+            // thread will not wake up until the top task's execution time is reached. This is not ideal, but it's good
+            // enough for this simple implementation.
+
+            auto now = Clock::now();
+            if (taskQueue.top().executionTime > now) {
+                taskQueueCV.wait_until(lock, taskQueue.top().executionTime);
+            }
+
+            auto task = std::move(taskQueue.top().task);
+            taskQueue.pop();
+            lock.unlock();
+
+            auto result = task();
+            if (result.has_value()) {
+                dispatch(std::move(task), *result);
+            }
+        }
+    }
+};

package/simpleble/src/external/ThreadRunner.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+class ThreadRunner {
+  public:
+    ThreadRunner() : _stop(false) { _thread = std::thread(&ThreadRunner::threadFunc, this); }
+
+    ~ThreadRunner() {
+        {
+            std::unique_lock<std::mutex> lock(_mutex);
+            _stop = true;
+            _cv.notify_one();
+        }
+        _thread.join();
+    }
+
+    void enqueue(std::function<void()> func) {
+        {
+            std::unique_lock<std::mutex> lock(_mutex);
+            _queue.push(std::move(func));
+            _cv.notify_one();
+        }
+    }
+
+  private:
+    void threadFunc() {
+        while (true) {
+            std::function<void()> func;
+            {
+                std::unique_lock<std::mutex> lock(_mutex);
+                _cv.wait(lock, [this] { return _stop || !_queue.empty(); });
+                if (_stop && _queue.empty()) {
+                    return;
+                }
+                func = std::move(_queue.front());
+                _queue.pop();
+            }
+            func();
+        }
+    }
+
+    std::thread _thread;
+    std::mutex _mutex;
+    std::condition_variable _cv;
+    std::queue<std::function<void()>> _queue;
+    bool _stop;
+};

package/simpleble/src/external/kvn_safe_callback.hpp

@@ -0,0 +1,66 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Kevin Dewald <kevin@dewald.me>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KVN_SAFE_CALLBACK_HPP
+#define KVN_SAFE_CALLBACK_HPP
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+
+namespace kvn {
+
+template <typename _Signature>
+class safe_callback;
+
+template <class _Res, class... _ArgTypes>
+class safe_callback<_Res(_ArgTypes...)> {
+  public:
+    safe_callback() = default;
+
+    // Remove copy constructor and copy assignment
+    safe_callback(const safe_callback&) = delete;
+    safe_callback& operator=(const safe_callback&) = delete;
+
+    virtual ~safe_callback() { unload(); };
+
+    void load(std::function<_Res(_ArgTypes...)> callback) {
+        if (callback == nullptr) return;
+
+        std::scoped_lock lock(_mutex);
+        _callback = std::move(callback);
+        _is_loaded = true;
+    }
+
+    void unload() {
+        std::scoped_lock lock(_mutex);
+        _callback = nullptr;
+        _is_loaded = false;
+    }
+
+    bool is_loaded() const { return _is_loaded; }
+
+    explicit operator bool() const { return is_loaded(); }
+
+    _Res operator()(_ArgTypes... arguments) {
+        std::scoped_lock lock(_mutex);
+        if (_is_loaded) {
+            return _callback(std::forward<_ArgTypes&&>(arguments)...);
+        } else {
+            return _Res();
+        }
+    }
+
+  protected:
+    std::atomic_bool _is_loaded{false};
+    std::function<_Res(_ArgTypes...)> _callback;
+    std::recursive_mutex _mutex;
+};
+
+}  // namespace kvn
+
+#endif  // KVN_SAFE_CALLBACK_HPP