simplejsble 0.0.4 → 0.0.6

package/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

package/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

package/simpleble/src/external/logfwd.hpp

@@ -0,0 +1,35 @@
+#ifndef LOGFWD_HPP
+#define LOGFWD_HPP
+
+#include <string>
+
+namespace logfwd {
+
+enum level : int {
+    NONE = 0,
+    FATAL,
+    ERROR,
+    WARN,
+    INFO,
+#pragma push_macro("DEBUG")
+#undef DEBUG
+    DEBUG,
+#pragma pop_macro("DEBUG")
+    VERBOSE,
+};
+
+// clang-format off
+
+void receive(
+    level level,
+    const std::string& module,
+    const std::string& file,
+    uint32_t line,
+    const std::string& function,
+    const std::string& message);
+
+// clang-format on
+
+}  // namespace logfwd
+
+#endif  // LOGFWD_HPP

package/simpleble/src/frontends/base/Adapter.cpp

@@ -0,0 +1,111 @@
+#include <simpleble/Adapter.h>
+#include "Backend.h"
+
+#include "BuildVec.h"
+#include "LoggingInternal.h"
+#include "backends/common/AdapterBase.h"
+
+using namespace SimpleBLE;
+
+std::vector<Adapter> Adapter::get_adapters() {
+    std::vector<Adapter> adapter_list;
+    for (auto& backend : Backend::get_backends()) {
+        for (auto& adapter : backend.get_adapters()) {
+            adapter_list.push_back(adapter);
+        }
+    }
+
+    return adapter_list;
+}
+
+// TODO: this should be the implementation of the per-backend bluetooth_enabled() function
+// bool Adapter::bluetooth_enabled() { return (*this)->bluetooth_enabled(); }
+
+bool Adapter::bluetooth_enabled() { return get_enabled_backend().bluetooth_enabled(); }
+
+bool Adapter::initialized() const { return internal_ != nullptr; }
+
+void* Adapter::underlying() const { return (*this)->underlying(); }
+
+/**
+ * Return the adapter implementation if it is initialized.
+ *
+ * @throws SimpleBLE::NotInitialized if the adapter is not initialized.
+ */
+AdapterBase* Adapter::operator->() {
+    if (!internal_) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+const AdapterBase* Adapter::operator->() const {
+    if (!internal_) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+std::string Adapter::identifier() { return (*this)->identifier(); }
+
+BluetoothAddress Adapter::address() { return (*this)->address(); }
+
+void Adapter::power_on() { (*this)->power_on(); }
+
+void Adapter::power_off() { (*this)->power_off(); }
+
+bool Adapter::is_powered() { return (*this)->is_powered(); }
+
+void Adapter::set_callback_on_power_on(std::function<void()> on_power_on) {
+    (*this)->set_callback_on_power_on(std::move(on_power_on));
+}
+
+void Adapter::set_callback_on_power_off(std::function<void()> on_power_off) {
+    (*this)->set_callback_on_power_off(std::move(on_power_off));
+}
+
+void Adapter::scan_start() {
+    if (!bluetooth_enabled()) {
+        SIMPLEBLE_LOG_WARN(fmt::format("Bluetooth is not enabled."));
+        return;
+    }
+    (*this)->scan_start();
+}
+
+void Adapter::scan_stop() {
+    if (!bluetooth_enabled()) {
+        SIMPLEBLE_LOG_WARN(fmt::format("Bluetooth is not enabled."));
+        return;
+    }
+    (*this)->scan_stop();
+}
+
+void Adapter::scan_for(int timeout_ms) {
+    if (!bluetooth_enabled()) {
+        SIMPLEBLE_LOG_WARN(fmt::format("Bluetooth is not enabled."));
+        return;
+    }
+    (*this)->scan_for(timeout_ms);
+}
+
+bool Adapter::scan_is_active() { return (*this)->scan_is_active(); }
+
+std::vector<Peripheral> Adapter::scan_get_results() { return Factory::vector((*this)->scan_get_results()); }
+
+std::vector<Peripheral> Adapter::get_paired_peripherals() { return Factory::vector((*this)->get_paired_peripherals()); }
+
+void Adapter::set_callback_on_scan_start(std::function<void()> on_scan_start) {
+    (*this)->set_callback_on_scan_start(std::move(on_scan_start));
+}
+
+void Adapter::set_callback_on_scan_stop(std::function<void()> on_scan_stop) {
+    (*this)->set_callback_on_scan_stop(std::move(on_scan_stop));
+}
+
+void Adapter::set_callback_on_scan_updated(std::function<void(Peripheral)> on_scan_updated) {
+    (*this)->set_callback_on_scan_updated(std::move(on_scan_updated));
+}
+
+void Adapter::set_callback_on_scan_found(std::function<void(Peripheral)> on_scan_found) {
+    (*this)->set_callback_on_scan_found(std::move(on_scan_found));
+}

package/simpleble/src/frontends/base/Advanced.cpp

@@ -0,0 +1,34 @@
+#include "simpleble/Advanced.h"
+
+#if defined(_WIN32)
+namespace SimpleBLE::Advanced::Windows {}
+
+#endif
+
+#if TARGET_OS_OSX
+namespace SimpleBLE::Advanced::MacOS {}
+
+#endif
+
+#if TARGET_OS_IOS
+namespace SimpleBLE::Advanced::iOS {}
+
+#endif
+
+#if defined(__ANDROID__)
+
+#include "simplejni/VM.hpp"
+
+namespace SimpleBLE::Advanced::Android {
+
+JavaVM* get_jvm() { return SimpleJNI::VM::jvm(); }
+void set_jvm(JavaVM* jvm) { SimpleJNI::VM::jvm(jvm); }
+
+}  // namespace SimpleBLE::Advanced::Android
+
+#endif
+
+#if defined(__linux__) && !defined(__ANDROID__)
+namespace SimpleBLE::Advanced::Linux {}
+
+#endif

package/simpleble/src/frontends/base/Backend.cpp

@@ -0,0 +1,95 @@
+#include <vector>
+
+#include <simpleble/Adapter.h>
+#include <simpleble/Config.h>
+#include <simpleble/Exceptions.h>
+
+#include "BackendBase.h"
+#include "BuildVec.h"
+#include "CommonUtils.h"
+
+#include "Backend.h"
+
+using namespace SimpleBLE;
+
+namespace SimpleBLE {
+
+static std::shared_ptr<BackendBase> _get_enabled_backend() {
+    using BackendPtr = std::shared_ptr<BackendBase>(void);
+
+    if (Config::Dongl::use_dongl_backend) {
+        extern BackendPtr BACKEND_DONGL;
+        return BACKEND_DONGL();
+    }
+
+    if constexpr (SIMPLEBLE_BACKEND_LINUX) {
+        extern BackendPtr BACKEND_LINUX;
+        extern BackendPtr BACKEND_LINUX_LEGACY;
+
+        if (Config::SimpleBluez::use_legacy_bluez_backend) {
+            return BACKEND_LINUX_LEGACY();
+        } else {
+            return BACKEND_LINUX();
+        }
+    } else if constexpr (SIMPLEBLE_BACKEND_WINDOWS) {
+        extern BackendPtr BACKEND_WINDOWS;
+        return BACKEND_WINDOWS();
+    } else if constexpr (SIMPLEBLE_BACKEND_ANDROID) {
+        extern BackendPtr BACKEND_ANDROID;
+        return BACKEND_ANDROID();
+    } else if constexpr (SIMPLEBLE_BACKEND_MACOS) {
+        extern BackendPtr BACKEND_MACOS;
+        return BACKEND_MACOS();
+    } else if constexpr (SIMPLEBLE_BACKEND_IOS) {
+        extern BackendPtr BACKEND_MACOS;
+        return BACKEND_MACOS();
+    } else if constexpr (SIMPLEBLE_BACKEND_PLAIN) {
+        extern BackendPtr BACKEND_PLAIN;
+        return BACKEND_PLAIN();
+    }
+
+    throw Exception::NotInitialized();
+}
+
+Backend get_enabled_backend() { return Factory::build(_get_enabled_backend()); }
+
+// NOTE: in the future, this can return multiple backends
+static SharedPtrVector<BackendBase> _get_backends() {
+    SharedPtrVector<BackendBase> backends = {_get_enabled_backend()};
+    return backends;
+}
+
+}  // namespace SimpleBLE
+
+std::vector<Backend> Backend::get_backends() { return Factory::vector(_get_backends()); }
+
+bool Backend::initialized() const { return internal_ != nullptr; }
+
+BackendBase* Backend::operator->() {
+    if (!initialized()) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+const BackendBase* Backend::operator->() const {
+    if (!initialized()) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+std::vector<Adapter> Backend::get_adapters() { return Factory::vector((*this)->get_adapters()); }
+
+bool Backend::bluetooth_enabled() { return (*this)->bluetooth_enabled(); }
+
+std::optional<Backend> Backend::first_bluetooth_enabled() {
+    for (auto& backend : get_backends()) {
+        if (backend->bluetooth_enabled()) {
+            return backend;
+        }
+    }
+    return std::nullopt;
+}
+
+std::string Backend::name() const noexcept { return (*this)->name(); }

package/simpleble/src/frontends/base/Backend.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <simpleble/Adapter.h>
+#include <simpleble/export.h>
+
+namespace SimpleBLE {
+
+class BackendBase;
+
+/**
+ * Backend.
+ *
+ * NOTE: backends must not implement this class directly, but instead derive
+ * from BackendBase, defined in Backend.h.
+ *
+ * This frontend class is hidden from users for the time being. Once the API
+ * stabilizes, this class will be exposed to users.
+ */
+class SIMPLEBLE_EXPORT Backend {
+  public:
+    Backend() = default;
+    virtual ~Backend() = default;
+
+    bool initialized() const;
+
+    /**
+     * Get a list of all available adapters from this backend.
+     */
+    std::vector<Adapter> get_adapters();
+
+    /**
+     * Check if Bluetooth is enabled for this backend.
+     */
+    bool bluetooth_enabled();
+
+    /**
+     * Get the first backend that has Bluetooth enabled.
+     *
+     * @return The first backend that has Bluetooth enabled, or std::nullopt if
+     *    no backends have Bluetooth enabled.
+     */
+    static std::optional<Backend> first_bluetooth_enabled();
+
+    /**
+     * Get the name of the backend.
+     */
+    std::string name() const noexcept;
+
+    /**
+     * Get all available backends.
+     *
+     * This will cause backends to be instantiated/initialized.
+     */
+    static std::vector<Backend> get_backends();
+
+  protected:
+    BackendBase* operator->();
+    const BackendBase* operator->() const;
+
+    std::shared_ptr<BackendBase> internal_;
+};
+
+/**
+ * Get the enabled backend.
+ *
+ * Note: this function should not be part of the public API and will be deleted
+ * once multiple backends are supported.
+ */
+Backend get_enabled_backend();
+
+}  // namespace SimpleBLE

package/simpleble/src/frontends/base/Characteristic.cpp

@@ -0,0 +1,56 @@
+#include <simpleble/Characteristic.h>
+
+#include "BuildVec.h"
+#include "CharacteristicBase.h"
+
+using namespace SimpleBLE;
+
+BluetoothUUID Characteristic::uuid() { return (*this)->uuid(); }
+
+std::vector<Descriptor> Characteristic::descriptors() { return Factory::vector((*this)->descriptors()); }
+
+std::vector<std::string> Characteristic::capabilities() {
+    std::vector<std::string> capabilities;
+
+    if (can_read()) {
+        capabilities.push_back("read");
+    }
+
+    if (can_write_request()) {
+        capabilities.push_back("write_request");
+    }
+
+    if (can_write_command()) {
+        capabilities.push_back("write_command");
+    }
+
+    if (can_notify()) {
+        capabilities.push_back("notify");
+    }
+
+    if (can_indicate()) {
+        capabilities.push_back("indicate");
+    }
+
+    return capabilities;
+}
+
+bool Characteristic::initialized() const { return internal_ != nullptr; }
+
+CharacteristicBase* Characteristic::operator->() {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+const CharacteristicBase* Characteristic::operator->() const {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+bool Characteristic::can_read() { return (*this)->can_read(); }
+bool Characteristic::can_write_request() { return (*this)->can_write_request(); }
+bool Characteristic::can_write_command() { return (*this)->can_write_command(); }
+bool Characteristic::can_notify() { return (*this)->can_notify(); }
+bool Characteristic::can_indicate() { return (*this)->can_indicate(); }

package/simpleble/src/frontends/base/Descriptor.cpp

@@ -0,0 +1,21 @@
+#include <simpleble/Descriptor.h>
+
+#include "DescriptorBase.h"
+
+using namespace SimpleBLE;
+
+bool Descriptor::initialized() const { return internal_ != nullptr; }
+
+DescriptorBase* Descriptor::operator->() {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+const DescriptorBase* Descriptor::operator->() const {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+BluetoothUUID Descriptor::uuid() { return (*this)->uuid(); }