simpleble 0.0.1

data/vendor/simpleble/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

data/vendor/simpleble/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

data/vendor/simpleble/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

data/vendor/simpleble/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

data/vendor/simpleble/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);
+            }
+        }
+    }
+};

data/vendor/simpleble/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;
+};

data/vendor/simpleble/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

data/vendor/simpleble/simpleble/src/external/kvn_safe_map.hpp

@@ -0,0 +1,94 @@
+/*
+ * Thread-safe map implementation with custom comparator support
+ */
+#ifndef KVN_SAFE_MAP_HPP
+#define KVN_SAFE_MAP_HPP
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+
+namespace kvn {
+
+template <typename _Key, typename _Value, typename _Compare = std::less<_Key>>
+class safe_map {
+  public:
+    safe_map() = default;
+    explicit safe_map(const _Compare& comp) : _map(comp) {}
+
+    // Remove copy constructor and copy assignment
+    safe_map(const safe_map&) = delete;
+    safe_map& operator=(const safe_map&) = delete;
+
+    // Move operations
+    safe_map(safe_map&&) noexcept = default;
+    safe_map& operator=(safe_map&&) noexcept = default;
+
+    // Add this inside the safe_map class
+    _Value& operator[](const _Key& key) {
+        std::scoped_lock lock(_mutex);
+        return _map[key];
+    }
+
+    const _Value& operator[](const _Key& key) const {
+        std::scoped_lock lock(_mutex);
+        return _map[key];
+    }
+
+    void insert(const _Key& key, const _Value& value) {
+        std::scoped_lock lock(_mutex);
+        _map.insert_or_assign(key, value);
+    }
+
+    void insert(_Key&& key, _Value&& value) {
+        std::scoped_lock lock(_mutex);
+        _map.insert_or_assign(std::move(key), std::move(value));
+    }
+
+    bool erase(const _Key& key) {
+        std::scoped_lock lock(_mutex);
+        return _map.erase(key) > 0;
+    }
+
+    std::optional<_Value> get(const _Key& key) const {
+        std::scoped_lock lock(_mutex);
+        auto it = _map.find(key);
+        if (it != _map.end()) {
+            return it->second;
+        }
+        return std::nullopt;
+    }
+
+    bool contains(const _Key& key) const {
+        std::scoped_lock lock(_mutex);
+        return _map.contains(key);
+    }
+
+    size_t size() const {
+        std::scoped_lock lock(_mutex);
+        return _map.size();
+    }
+
+    void clear() {
+        std::scoped_lock lock(_mutex);
+        _map.clear();
+    }
+
+    template <typename _Func>
+    void atomic_update(const _Key& key, _Func update_func) {
+        std::scoped_lock lock(_mutex);
+        auto it = _map.find(key);
+        if (it != _map.end()) {
+            update_func(it->second);
+        }
+    }
+
+  protected:
+    mutable std::recursive_mutex _mutex;
+    std::map<_Key, _Value, _Compare> _map;
+};
+
+}  // namespace kvn
+
+#endif  // KVN_SAFE_MAP_HPP

data/vendor/simpleble/simpleble/src/external/kvn_threadrunner.hpp

@@ -0,0 +1,70 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Kevin Dewald <kevin@dewald.me>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef KVN_THREADRUNNER_HPP
+#define KVN_THREADRUNNER_HPP
+
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+namespace kvn {
+
+class thread_runner {
+  public:
+    thread_runner() : _stop(false) { _thread = std::thread(&thread_runner::thread_func, this); }
+
+    // Remove copy constructor and copy assignment
+    thread_runner(const thread_runner&) = delete;
+    thread_runner& operator=(const thread_runner&) = delete;
+
+    virtual ~thread_runner() {
+        {
+            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));
+            lock.unlock();  // Unlock before notify
+            _cv.notify_one();
+        }
+    }
+
+  protected:
+    void thread_func() {
+        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;
+};
+
+}  // namespace kvn
+
+#endif  // KVN_THREADRUNNER_HPP