simpleble 0.0.1

data/vendor/simpleble/dependencies/internal/simplejni/References.hpp

@@ -0,0 +1,151 @@
+#pragma once
+
+#include <jni.h>
+
+#include "VM.hpp"
+
+namespace SimpleJNI {
+
+template <typename T>
+class GlobalRef {
+  public:
+    GlobalRef() = default;
+
+    explicit GlobalRef(T obj) : _obj(obj ? static_cast<T>(VM::env()->NewGlobalRef(obj)) : nullptr) {}
+
+    ~GlobalRef() {
+        if (_obj && VM::is_jvm_alive()) VM::env()->DeleteGlobalRef(_obj);
+    }
+
+    // Copy constructor
+    GlobalRef(const GlobalRef& other)
+        : _obj(other._obj ? static_cast<T>(VM::env()->NewGlobalRef(other._obj)) : nullptr) {}
+
+    // Copy assignment operator
+    GlobalRef& operator=(const GlobalRef& other) {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteGlobalRef(_obj);
+            _obj = other._obj ? static_cast<T>(VM::env()->NewGlobalRef(other._obj)) : nullptr;
+        }
+        return *this;
+    }
+
+    // Move constructor
+    GlobalRef(GlobalRef&& other) noexcept : _obj(other._obj) { other._obj = nullptr; }
+
+    // Move assignment operator
+    GlobalRef& operator=(GlobalRef&& other) noexcept {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteGlobalRef(_obj);
+            _obj = other._obj;
+            other._obj = nullptr;
+        }
+        return *this;
+    }
+
+    T get() const { return _obj; }
+
+  protected:
+    T _obj = nullptr;
+};
+
+template <typename T>
+class LocalRef {
+  public:
+    LocalRef() = default;
+
+    explicit LocalRef(T obj) : _obj(obj ? static_cast<T>(VM::env()->NewLocalRef(obj)) : nullptr) {}
+
+    ~LocalRef() {
+        if (_obj) VM::env()->DeleteLocalRef(_obj);
+    }
+
+    // Copy constructor
+    LocalRef(const LocalRef& other) : _obj(other._obj ? static_cast<T>(VM::env()->NewLocalRef(other._obj)) : nullptr) {}
+
+    // Copy assignment operator
+    LocalRef& operator=(const LocalRef& other) {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteLocalRef(_obj);
+            _obj = other._obj ? static_cast<T>(VM::env()->NewLocalRef(other._obj)) : nullptr;
+        }
+        return *this;
+    }
+
+    // Move constructor
+    LocalRef(LocalRef&& other) noexcept : _obj(other._obj) { other._obj = nullptr; }
+
+    // Move assignment operator
+    LocalRef& operator=(LocalRef&& other) noexcept {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteLocalRef(_obj);
+            _obj = other._obj;
+            other._obj = nullptr;
+        }
+        return *this;
+    }
+
+    T get() const { return _obj; }
+
+  protected:
+    T _obj = nullptr;
+};
+
+// A type for references intended to be returned to JNI
+template <typename T>
+class ReleasableLocalRef : public LocalRef<T> {
+  public:
+    using LocalRef<T>::LocalRef;
+    T release() noexcept {
+        T obj = this->_obj;
+        this->_obj = nullptr;
+        return obj;
+    }
+};
+
+template <typename T>
+class WeakRef {
+  public:
+    WeakRef() = default;
+
+    explicit WeakRef(T obj) : _obj(obj ? static_cast<T>(VM::env()->NewWeakGlobalRef(obj)) : nullptr) {}
+
+    ~WeakRef() {
+        if (_obj && VM::is_jvm_alive()) VM::env()->DeleteWeakGlobalRef(_obj);
+    }
+
+    // Copy constructor
+    WeakRef(const WeakRef& other)
+        : _obj(other._obj ? static_cast<T>(VM::env()->NewWeakGlobalRef(other._obj)) : nullptr) {}
+
+    // Copy assignment operator
+    WeakRef& operator=(const WeakRef& other) {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteWeakGlobalRef(_obj);
+            _obj = other._obj ? static_cast<T>(VM::env()->NewWeakGlobalRef(other._obj)) : nullptr;
+        }
+        return *this;
+    }
+
+    // Move constructor
+    WeakRef(WeakRef&& other) noexcept : _obj(other._obj) { other._obj = nullptr; }
+
+    // Move assignment operator
+    WeakRef& operator=(WeakRef&& other) noexcept {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteWeakGlobalRef(_obj);
+            _obj = other._obj;
+            other._obj = nullptr;
+        }
+        return *this;
+    }
+
+    T get() const { return _obj; }
+
+    bool is_valid() const { return _obj && !VM::env()->IsSameObject(_obj, nullptr); }
+
+  protected:
+    T _obj = nullptr;
+};
+
+}  // namespace SimpleJNI

data/vendor/simpleble/dependencies/internal/simplejni/Registry.hpp

@@ -0,0 +1,183 @@
+#pragma once
+#include <string>
+#include <vector>
+#include "Common.hpp"
+
+namespace SimpleJNI {
+
+/**
+ * @brief Descriptor for a single Java method to be preloaded.
+ *
+ * This struct holds the metadata for a method that a Java class needs to expose to C++.
+ * It links a method name and signature to a jmethodID pointer where the resolved ID will
+ * be stored during JNI_OnLoad.
+ */
+struct MethodDescriptor {
+    std::string name;             ///< Name of the Java method (e.g., "startScan").
+    std::string signature;        ///< JNI signature of the method (e.g., "(Landroid/bluetooth/le/ScanCallback;)V").
+    jmethodID* target = nullptr;  ///< Pointer to where the resolved jmethodID will be stored.
+
+    MethodDescriptor(const std::string& n, const std::string& sig, jmethodID* tgt)
+        : name(n), signature(sig), target(tgt) {}
+};
+
+/**
+ * @brief Descriptor for a Java class and its methods to be preloaded.
+ *
+ * This struct defines a Java class by its fully qualified name and a list of methods
+ * that need JNI access. It ties the class and its methods to storage locations
+ * (GlobalRef<jclass> and jmethodID pointers) that will be populated during preloading.
+ */
+struct JNIDescriptor {
+    std::string class_name;  ///< Fully qualified Java class name (e.g., "android/bluetooth/le/BluetoothLeScanner").
+    SimpleJNI::GlobalRef<jclass>* class_target;  ///< Pointer to where the resolved jclass will be stored.
+    std::vector<MethodDescriptor> methods;       ///< List of methods to preload for this class.
+
+    JNIDescriptor(const std::string& name, SimpleJNI::GlobalRef<jclass>* cls_target,
+                  std::initializer_list<MethodDescriptor> meths)
+        : class_name(name), class_target(cls_target), methods(meths) {}
+};
+
+/**
+ * @brief Descriptor for a Java class and its static methods to be preloaded.
+ *
+ * This struct defines a Java class by its fully qualified name and a list of static methods
+ * that need JNI access. It ties the class and its static methods to storage locations
+ * (GlobalRef<jclass> and jmethodID pointers) that will be populated during preloading.
+ */
+struct StaticJNIDescriptor {
+    std::string class_name;  ///< Fully qualified Java class name (e.g., "android/bluetooth/le/BluetoothLeScanner").
+    SimpleJNI::GlobalRef<jclass>* class_target;  ///< Pointer to where the resolved jclass will be stored.
+    std::vector<MethodDescriptor> static_methods;  ///< List of static methods to preload for this class.
+
+    StaticJNIDescriptor(const std::string& name, SimpleJNI::GlobalRef<jclass>* cls_target,
+                        std::initializer_list<MethodDescriptor> meths)
+        : class_name(name), class_target(cls_target), static_methods(meths) {}
+};
+
+/**
+ * @brief Singleton registrar for collecting and preloading JNI class descriptors.
+ *
+ * The Registrar collects JNIDescriptor and StaticJNIDescriptor instances at compile-time
+ * (via static initialization) and preloads their JNI resources (jclass and jmethodID)
+ * during JNI_OnLoad. This ensures all necessary JNI metadata is resolved early on the
+ * correct thread, avoiding runtime ClassLoader or thread-context issues.
+ */
+class Registrar {
+  public:
+    /// @brief Get the singleton instance of the Registrar.
+    static Registrar& get() {
+        static Registrar instance;
+        return instance;
+    }
+
+    /**
+     * @brief Register a JNIDescriptor for preloading.
+     *
+     * Called automatically by AutoRegister during static initialization. Adds the descriptor
+     * to an internal list that will be processed in preload().
+     * @param descriptor Pointer to the JNIDescriptor to register.
+     */
+    void register_descriptor(const JNIDescriptor* descriptor) { descriptors.push_back(descriptor); }
+
+    /**
+     * @brief Register a StaticJNIDescriptor for preloading.
+     *
+     * Called automatically by AutoRegister during static initialization. Adds the descriptor
+     * to an internal list that will be processed in preload().
+     * @param descriptor Pointer to the StaticJNIDescriptor to register.
+     */
+    void register_static_descriptor(const StaticJNIDescriptor* descriptor) {
+        static_descriptors.push_back(descriptor);
+    }
+
+    /**
+     * @brief Preload all registered JNI resources.
+     *
+     * Called from JNI_OnLoad to resolve jclass and jmethodID for all registered descriptors.
+     * Uses the provided JNIEnv to perform JNI lookups on the thread that loads the library,
+     * ensuring access to the correct ClassLoader context (e.g., system classes on Android).
+     * @param env JNIEnv pointer from JNI_OnLoad.
+     * @throws std::runtime_error if a class or method cannot be resolved.
+     */
+    void preload(JNIEnv* env) {
+        // Preload instance method descriptors
+        for (const JNIDescriptor* desc : descriptors) {
+            // Load the Java class
+            jclass local_cls = env->FindClass(desc->class_name.c_str());
+            if (!local_cls) {
+                throw std::runtime_error("Failed to load class: " + desc->class_name);
+            }
+            *desc->class_target = SimpleJNI::GlobalRef<jclass>(local_cls);
+            env->DeleteLocalRef(local_cls);  // Clean up the local reference
+
+            // Load each method
+            for (const MethodDescriptor& method : desc->methods) {
+                *method.target = env->GetMethodID(desc->class_target->get(), method.name.c_str(),
+                                                  method.signature.c_str());
+                if (!*method.target) {
+                    throw std::runtime_error("Failed to get method: " + desc->class_name + "." + method.name);
+                }
+            }
+        }
+
+        // Preload static method descriptors
+        for (const StaticJNIDescriptor* desc : static_descriptors) {
+            // Load the Java class
+            jclass local_cls = env->FindClass(desc->class_name.c_str());
+            if (!local_cls) {
+                throw std::runtime_error("Failed to load class: " + desc->class_name);
+            }
+            *desc->class_target = SimpleJNI::GlobalRef<jclass>(local_cls);
+            env->DeleteLocalRef(local_cls);  // Clean up the local reference
+
+            // Load each static method
+            for (const MethodDescriptor& method : desc->static_methods) {
+                *method.target = env->GetStaticMethodID(desc->class_target->get(), method.name.c_str(),
+                                                        method.signature.c_str());
+                if (!*method.target) {
+                    throw std::runtime_error("Failed to get static method: " + desc->class_name + "." + method.name);
+                }
+            }
+        }
+    }
+
+  private:
+    Registrar() = default;
+    ~Registrar() = default;
+    Registrar(const Registrar&) = delete;
+    Registrar& operator=(const Registrar&) = delete;
+
+    std::vector<const JNIDescriptor*> descriptors;  ///< List of registered descriptors.
+    std::vector<const StaticJNIDescriptor*> static_descriptors;  ///< List of registered static descriptors.
+};
+
+/**
+ * @brief Helper to automatically register JNI descriptors at compile time.
+ *
+ * This template class uses static initialization to register descriptors with the Registrar
+ * when the program loads. The constructor runs before main() or JNI_OnLoad, ensuring all
+ * classes are registered without manual intervention. It supports registering non-static methods,
+ * static methods, or both.
+ * @tparam T The class type (e.g., BluetoothScanner) that owns the descriptor.
+ */
+template <typename T>
+struct AutoRegister {
+    // Constructor for non-static methods only
+    AutoRegister(const JNIDescriptor* desc) {
+        Registrar::get().register_descriptor(desc);
+    }
+
+    // Constructor for static methods only
+    AutoRegister(const StaticJNIDescriptor* static_desc) {
+        Registrar::get().register_static_descriptor(static_desc);
+    }
+
+    // Constructor for both non-static and static methods
+    AutoRegister(const JNIDescriptor* desc, const StaticJNIDescriptor* static_desc) {
+        Registrar::get().register_descriptor(desc);
+        Registrar::get().register_static_descriptor(static_desc);
+    }
+};
+
+}  // namespace SimpleJNI

data/vendor/simpleble/dependencies/internal/simplejni/VM.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <jni.h>
+
+#include <mutex>
+
+namespace SimpleJNI {
+
+// Generic class to handle the Java Virtual Machine (JVM)
+class VM {
+  public:
+    // TODO: Make the VM class transparent to the JavaVM pointer.
+    static JavaVM* jvm() {
+        static std::mutex get_mutex;  // Static mutex to ensure thread safety when accessing the VM
+        static VM instance;           // Static instance of the VM to ensure proper lifecycle management
+
+        if (instance._jvm == nullptr) {
+            std::scoped_lock lock(get_mutex);  // Unlock the mutex on function return
+            jsize count;
+            if (JNI_GetCreatedJavaVMs(&instance._jvm, 1, &count) != JNI_OK || count == 0) {
+                throw std::runtime_error("Failed to get the Java Virtual Machine");
+            }
+        }
+        return instance._jvm;
+    }
+
+    static bool is_jvm_alive() {
+        JavaVM* jvm = VM::jvm();
+        if (!jvm) return false;
+        JNIEnv* env = nullptr;
+        return jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) == JNI_OK;
+    }
+
+    static JNIEnv* env() {
+        JNIEnv* env = nullptr;
+        JavaVM* jvm = VM::jvm();
+
+        auto getEnvResult = jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
+        switch (getEnvResult) {
+            case JNI_OK:
+                break;
+            case JNI_EDETACHED: {
+#ifdef __ANDROID__
+                auto result = jvm->AttachCurrentThread(&env, nullptr);
+#else
+                auto result = jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), nullptr);
+#endif
+                if (result != JNI_OK) {
+                    throw std::runtime_error("Failed to attach the current thread to the JVM");
+                }
+                break;
+            }
+            case JNI_EVERSION:
+                throw std::runtime_error("Failed to get the JNIEnv, JNI version not supported");
+            default:
+                throw std::runtime_error("Failed to get the JNIEnv, unknown error");
+        }
+        return env;
+    }
+
+    static void attach() {
+        JNIEnv* env = nullptr;
+        JavaVM* jvm = VM::jvm();
+#ifdef __ANDROID__
+        auto result = jvm->AttachCurrentThread(&env, nullptr);
+#else
+        auto result = jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), nullptr);
+#endif
+        if (result != JNI_OK) {
+            throw std::runtime_error("Failed to attach the current thread to the JVM");
+        }
+    }
+
+    static void detach() {
+        JavaVM* jvm = VM::jvm();
+        jvm->DetachCurrentThread();
+    }
+
+  private:
+    VM() = default;
+    virtual ~VM() = default;
+    VM(VM& other) = delete;              // Remove the copy constructor
+    void operator=(const VM&) = delete;  // Remove the copy assignment
+
+    JavaVM* _jvm = nullptr;
+};
+
+}  // namespace SimpleJNI

data/vendor/simpleble/examples/simpleble/src/connect.cpp

@@ -0,0 +1,67 @@
+#include <iostream>
+#include <vector>
+
+#include "utils.hpp"
+
+#include "simpleble/SimpleBLE.h"
+
+int main() {
+    auto adapter_optional = Utils::getAdapter();
+
+    if (!adapter_optional.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto adapter = adapter_optional.value();
+
+    std::vector<SimpleBLE::Peripheral> peripherals;
+
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+        if (peripheral.is_connectable()) {
+            peripherals.push_back(peripheral);
+        }
+    });
+
+    adapter.set_callback_on_scan_start([]() { std::cout << "Scan started." << std::endl; });
+    adapter.set_callback_on_scan_stop([]() { std::cout << "Scan stopped." << std::endl; });
+    // Scan for 5 seconds and return.
+    adapter.scan_for(5000);
+
+    std::cout << "The following connectable devices were found:" << std::endl;
+    for (size_t i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i].identifier() << " [" << peripherals[i].address() << "]"
+                  << std::endl;
+    }
+
+    auto selection = Utils::getUserInputInt("Please select a device to connect to", peripherals.size() - 1);
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto peripheral = peripherals[selection.value()];
+    std::cout << "Connecting to " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+    peripheral.connect();
+
+    std::cout << "Successfully connected." << std::endl;
+    std::cout << "MTU: " << peripheral.mtu() << std::endl;
+    for (auto& service : peripheral.services()) {
+        std::cout << "Service: " << service.uuid() << std::endl;
+
+        for (auto& characteristic : service.characteristics()) {
+            std::cout << "  Characteristic: " << characteristic.uuid() << std::endl;
+
+            std::cout << "    Capabilities: ";
+            for (auto& capability : characteristic.capabilities()) {
+                std::cout << capability << " ";
+            }
+            std::cout << std::endl;
+
+            for (auto& descriptor : characteristic.descriptors()) {
+                std::cout << "    Descriptor: " << descriptor.uuid() << std::endl;
+            }
+        }
+    }
+    peripheral.disconnect();
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/connect_safe.cpp

@@ -0,0 +1,91 @@
+#include <iostream>
+#include <vector>
+
+#include "utils.hpp"
+
+#include "simpleble/SimpleBLE.h"
+
+int main() {
+    auto adapter_list = SimpleBLE::Safe::Adapter::get_adapters();
+
+    if (!adapter_list.has_value()) {
+        std::cout << "Failed to list adapters" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    if (adapter_list->empty()) {
+        std::cout << "No adapter was found." << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    std::cout << "Available adapters: \n";
+    int i = 0;
+    for (auto& adapter : *adapter_list) {
+        std::cout << "[" << i++ << "] " << adapter.identifier().value() << " [" << adapter.address().value() << "]"
+                  << std::endl;
+    }
+
+    auto adapter_selection = Utils::getUserInputInt("Please select an adapter", adapter_list->size() - 1);
+    if (!adapter_selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter& adapter = adapter_list->at(adapter_selection.value());
+
+    std::vector<SimpleBLE::Safe::Peripheral> peripherals;
+
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Safe::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier().value_or("UNKNOWN") << " ["
+                  << peripheral.address().value_or("UNKNOWN") << "]" << std::endl;
+        peripherals.push_back(peripheral);
+    });
+
+    adapter.set_callback_on_scan_start([]() { std::cout << "Scan started." << std::endl; });
+    adapter.set_callback_on_scan_stop([]() { std::cout << "Scan stopped." << std::endl; });
+    // Scan for 5 seconds and return.
+    adapter.scan_for(5000);
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (size_t i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i].identifier().value_or("UNKNOWN") << " ["
+                  << peripherals[i].address().value_or("UNKNOWN") << "]" << std::endl;
+    }
+
+    auto selection = Utils::getUserInputInt("Please select a device to connect to", peripherals.size() - 1);
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto peripheral = peripherals[selection.value()];
+    std::cout << "Connecting to " << peripheral.identifier().value_or("UNKNOWN") << " ["
+              << peripheral.address().value_or("UNKNOWN") << "]" << std::endl;
+
+    // If the connection wasn't successful, no exception will be thrown.
+    bool connect_was_successful = peripheral.connect();
+    if (!connect_was_successful) {
+        std::cout << "Failed to connect to " << peripheral.identifier().value_or("UNKNOWN") << " ["
+                  << peripheral.address().value_or("UNKNOWN") << "]" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    std::cout << "Successfully connected, listing services." << std::endl;
+    auto services = peripheral.services();
+
+    if (!services.has_value()) {
+        std::cout << "Failed to list services." << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    for (auto service : *services) {
+        std::cout << "Service: " << service.uuid() << std::endl;
+        for (auto characteristic : service.characteristics()) {
+            std::cout << "  Characteristic: " << characteristic.uuid() << std::endl;
+
+            for (auto& descriptor : characteristic.descriptors()) {
+                std::cout << "  Descriptor: " << descriptor.uuid() << std::endl;
+            }
+        }
+    }
+    peripheral.disconnect();
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/list_adapters.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+
+#include "simpleble/Adapter.h"
+#include "simpleble/Utils.h"
+
+int main() {
+    std::cout << "Using SimpleBLE version: " << SimpleBLE::get_simpleble_version() << std::endl;
+    std::cout << "Bluetooth enabled: " << SimpleBLE::Adapter::bluetooth_enabled() << std::endl;
+
+    auto adapter_list = SimpleBLE::Adapter::get_adapters();
+
+    if (adapter_list.empty()) {
+        std::cout << "No adapter found" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    for (auto& adapter : adapter_list) {
+        std::cout << "Adapter: " << adapter.identifier() << " [" << adapter.address() << "]" << std::endl;
+    }
+
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/list_adapters_safe.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+
+#include "simpleble/AdapterSafe.h"
+
+int main() {
+    auto bluetooth_enabled = SimpleBLE::Safe::Adapter::bluetooth_enabled();
+
+    if (!bluetooth_enabled.has_value()) {
+        std::cout << "Failed to determine Bluetooth status" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    std::cout << "Bluetooth enabled: " << bluetooth_enabled.value() << std::endl;
+
+    auto adapter_list = SimpleBLE::Safe::Adapter::get_adapters();
+
+    if (!adapter_list.has_value()) {
+        std::cout << "Failed to list adapters" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    if (adapter_list->empty()) {
+        std::cout << "No adapter found" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    for (auto& adapter : *adapter_list) {
+        std::cout << "Adapter: " << adapter.identifier().value() << " [" << adapter.address().value() << "]"
+                  << std::endl;
+    }
+
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/list_paired.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+
+#include "simpleble/Adapter.h"
+#include "simpleble/Utils.h"
+
+int main() {
+    std::cout << "Using SimpleBLE version: " << SimpleBLE::get_simpleble_version() << std::endl;
+    std::cout << "Bluetooth enabled: " << SimpleBLE::Adapter::bluetooth_enabled() << std::endl;
+
+    auto adapter_list = SimpleBLE::Adapter::get_adapters();
+
+    if (adapter_list.empty()) {
+        std::cout << "No adapter found" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    for (auto& adapter : adapter_list) {
+        std::cout << "Adapter: " << adapter.identifier() << " [" << adapter.address() << "]" << std::endl;
+
+        auto peripherals = adapter.get_paired_peripherals();
+        for (auto& peripheral : peripherals) {
+            std::cout << "  Peripheral: " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+        }
+    }
+
+    return EXIT_SUCCESS;
+}