simpleble 0.0.1

data/vendor/simpleble/examples/simplecble/c/scan.c

@@ -0,0 +1,164 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef _WIN32
+#define SLEEP_SEC(x) _sleep(x * 1000)
+#else
+#include <unistd.h>
+#define SLEEP_SEC(x) sleep(x)
+#endif
+
+#include "simpleble_c/simpleble.h"
+
+static void print_buffer_hex(uint8_t* buf, size_t len, bool newline) {
+    for (size_t i = 0; i < len; i++) {
+        printf("%02X", buf[i]);
+
+        if (i < (len - 1)) {
+            printf(" ");
+        }
+    }
+
+    if (newline) {
+        printf("\n");
+    }
+}
+
+static void adapter_on_scan_start(simpleble_adapter_t adapter, void* userdata);
+static void adapter_on_scan_stop(simpleble_adapter_t adapter, void* userdata);
+static void adapter_on_scan_found(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata);
+static void adapter_on_scan_updated(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata);
+
+int main() {
+    // NOTE: It's necessary to call this function before any other to allow the
+    // underlying driver to run its initialization routine.
+    size_t adapter_count = simpleble_adapter_get_count();
+    if (adapter_count == 0) {
+        printf("No adapter was found.\n");
+        return 1;
+    }
+
+    // TODO: Allow the user to pick an adapter.
+    simpleble_adapter_t adapter = simpleble_adapter_get_handle(0);
+    if (adapter == NULL) {
+        printf("No adapter was found.\n");
+        return 1;
+    }
+
+    simpleble_adapter_set_callback_on_scan_start(adapter, adapter_on_scan_start, NULL);
+    simpleble_adapter_set_callback_on_scan_stop(adapter, adapter_on_scan_stop, NULL);
+    simpleble_adapter_set_callback_on_scan_found(adapter, adapter_on_scan_found, NULL);
+    simpleble_adapter_set_callback_on_scan_updated(adapter, adapter_on_scan_updated, NULL);
+
+    simpleble_adapter_scan_for(adapter, 5000);
+
+    // Sleep for an additional second before returning.
+    // If there are any detections during this period, it means that the
+    // internal peripheral took longer to stop than anticipated.
+    SLEEP_SEC(1);
+
+    size_t peripheral_count = simpleble_adapter_scan_get_results_count(adapter);
+    for (size_t peripheral_index = 0; peripheral_index < peripheral_count; peripheral_index++) {
+        simpleble_peripheral_t peripheral = simpleble_adapter_scan_get_results_handle(adapter, peripheral_index);
+
+        char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+        char* peripheral_address = simpleble_peripheral_address(peripheral);
+
+        bool peripheral_connectable = false;
+        simpleble_peripheral_is_connectable(peripheral, &peripheral_connectable);
+
+        int16_t peripheral_rssi = simpleble_peripheral_rssi(peripheral);
+
+        printf("[%zu] %s [%s] %d dBm %s\n", peripheral_index, peripheral_identifier, peripheral_address,
+               peripheral_rssi, peripheral_connectable ? "Connectable" : "Non-Connectable");
+
+        size_t services_count = simpleble_peripheral_services_count(peripheral);
+        for (size_t service_index = 0; service_index < services_count; service_index++) {
+            simpleble_service_t service;
+            simpleble_peripheral_services_get(peripheral, service_index, &service);
+
+            printf("    Service UUID: %s\n", service.uuid.value);
+            printf("    Service data: ");
+            print_buffer_hex(service.data, service.data_length, true);
+        }
+
+        size_t manufacturer_data_count = simpleble_peripheral_manufacturer_data_count(peripheral);
+        for (size_t manuf_data_index = 0; manuf_data_index < manufacturer_data_count; manuf_data_index++) {
+            simpleble_manufacturer_data_t manuf_data;
+            simpleble_peripheral_manufacturer_data_get(peripheral, manuf_data_index, &manuf_data);
+            printf("    Manufacturer ID: %04X\n", manuf_data.manufacturer_id);
+            printf("    Manufacturer data: ");
+            print_buffer_hex(manuf_data.data, manuf_data.data_length, true);
+        }
+
+        // Let's not forget to release the associated handles and memory
+        simpleble_peripheral_release_handle(peripheral);
+        simpleble_free(peripheral_address);
+        simpleble_free(peripheral_identifier);
+    }
+
+    // Let's not forget to release the associated handle.
+    simpleble_adapter_release_handle(adapter);
+
+    return 0;
+}
+
+static void adapter_on_scan_start(simpleble_adapter_t adapter, void* userdata) {
+    char* identifier = simpleble_adapter_identifier(adapter);
+
+    if (identifier == NULL) {
+        return;
+    }
+
+    printf("Adapter %s started scanning.\n", identifier);
+
+    // Let's not forget to clear the allocated memory.
+    simpleble_free(identifier);
+}
+
+static void adapter_on_scan_stop(simpleble_adapter_t adapter, void* userdata) {
+    char* identifier = simpleble_adapter_identifier(adapter);
+
+    if (identifier == NULL) {
+        return;
+    }
+
+    printf("Adapter %s stopped scanning.\n", identifier);
+
+    // Let's not forget to clear the allocated memory.
+    simpleble_free(identifier);
+}
+
+static void adapter_on_scan_found(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata) {
+    char* adapter_identifier = simpleble_adapter_identifier(adapter);
+    char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+    char* peripheral_address = simpleble_peripheral_address(peripheral);
+
+    if (adapter_identifier == NULL || peripheral_identifier == NULL || peripheral_address == NULL) {
+        return;
+    }
+
+    printf("Adapter %s found device: %s [%s]\n", adapter_identifier, peripheral_identifier, peripheral_address);
+
+    // Let's not forget to release the associated handles and memory
+    simpleble_peripheral_release_handle(peripheral);
+    simpleble_free(peripheral_address);
+    simpleble_free(peripheral_identifier);
+}
+
+static void adapter_on_scan_updated(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata) {
+    char* adapter_identifier = simpleble_adapter_identifier(adapter);
+    char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+    char* peripheral_address = simpleble_peripheral_address(peripheral);
+
+    if (adapter_identifier == NULL || peripheral_identifier == NULL || peripheral_address == NULL) {
+        return;
+    }
+
+    printf("Adapter %s updated device: %s [%s]\n", adapter_identifier, peripheral_identifier, peripheral_address);
+
+    // Let's not forget to release the associated handles and memory
+    simpleble_peripheral_release_handle(peripheral);
+    simpleble_free(peripheral_address);
+    simpleble_free(peripheral_identifier);
+}

data/vendor/simpleble/examples/simpledbus/notification.cpp

@@ -0,0 +1,24 @@
+#include <simpledbus/base/Connection.h>
+#include <simpledbus/base/Message.h>
+
+int main(int argc, char* argv[]) {
+    SimpleDBus::Connection conn(DBUS_BUS_SESSION);
+    conn.init();
+
+    auto msg = SimpleDBus::Message::create_method_call(
+        "org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "Notify");
+
+    // For information on these arguments, have a look at the interface definition.
+    msg.append_argument(SimpleDBus::Holder::create_string("SimpleDBUS Example"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(SimpleDBus::Holder::create_uint32(42), DBUS_TYPE_UINT32_AS_STRING);
+    msg.append_argument(SimpleDBus::Holder::create_string("ubuntu-logo"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(SimpleDBus::Holder::create_string("SimpleDBus Notify Summary"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(SimpleDBus::Holder::create_string("This is a SimpleDBus notification."),
+                        DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(SimpleDBus::Holder::create_array(), "as");
+    msg.append_argument(SimpleDBus::Holder::create_dict(), "a{sv}");
+    msg.append_argument(SimpleDBus::Holder::create_int32(5000), DBUS_TYPE_INT32_AS_STRING);
+    conn.send_with_reply_and_block(msg);
+
+    return 0;
+}

data/vendor/simpleble/hitl/src/test_sanity.cpp

@@ -0,0 +1,48 @@
+#include <gtest/gtest.h>
+#include <chrono>
+#include <thread>
+#include "simpleble/SimpleBLE.h"
+
+TEST(BLESanityTest, FullSequentialTest) {
+    // Initialize adapter
+    auto adapters = SimpleBLE::Adapter::get_adapters();
+    ASSERT_FALSE(adapters.empty()) << "No Bluetooth adapters found";
+    SimpleBLE::Adapter adapter = adapters[0];
+    EXPECT_TRUE(adapter.bluetooth_enabled());
+
+    // Scan for device
+    SimpleBLE::Peripheral target_peripheral;
+    const std::string TARGET_MAC = "11:22:33:44:55:66";  // Replace with your device's MAC
+    const std::string TARGET_NAME = "SimpleBLE DUT";
+    bool device_found = false;
+
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier() << " (" << peripheral.address() << ")" << std::endl;
+
+        if (peripheral.address() == TARGET_MAC || peripheral.identifier() == TARGET_NAME) {
+            target_peripheral = peripheral;
+            device_found = true;
+        }
+    });
+
+    adapter.scan_for(10000);
+    ASSERT_TRUE(device_found) << "Target device not found during scan";
+    EXPECT_EQ(target_peripheral.identifier(), TARGET_NAME);
+    EXPECT_TRUE(target_peripheral.is_connectable());
+
+    // Connect and check services
+    ASSERT_NO_THROW(target_peripheral.connect()) << "Failed to connect to target device";
+
+    auto services = target_peripheral.services();
+    EXPECT_FALSE(services.empty()) << "No services found on connected device";
+
+    // Print services for debugging
+    for (auto& service : services) {
+        std::cout << "Found service: " << service.uuid() << std::endl;
+    }
+
+    // Cleanup
+    if (target_peripheral.is_connected()) {
+        target_peripheral.disconnect();
+    }
+}

data/vendor/simpleble/install_simplecble/include/simpleble/Adapter.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Peripheral.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class AdapterBase;
+
+/**
+ * Bluetooth Adapter.
+ *
+ * A default-constructed Adapter object is not initialized. Calling any method
+ * other than `initialized()` on an uninitialized Adapter will throw an exception
+ * of type `SimpleBLE::NotInitialized`.
+ *
+ * NOTE: This class is intended to be used by the user only. Library developers
+ * should use shared pointers to `AdapterBase` instead.
+ */
+class SIMPLEBLE_EXPORT Adapter {
+  public:
+    Adapter() = default;
+    virtual ~Adapter() = default;
+
+    bool initialized() const;
+
+    /**
+     * Retrieve the underlying OS object/handle.
+     *
+     * For certain compatibility with external libraries, we sometimes need to
+     * expose the actual OS handle to the user. This is particularly important
+     * for MacOS right now.
+     */
+    void* underlying() const;
+
+    std::string identifier();
+    BluetoothAddress address();
+
+    /**
+     * Control the power state of the adapter.
+     *
+     * NOTE: The power on/off functionality is only supported on Windows and Linux (implementation pending).
+     *       On other platforms, this method will do nothing.
+     * NOTE: Callbacks are currently a placeholder for future implementation.
+     */
+    void power_on();
+    void power_off();
+    bool is_powered();
+    void set_callback_on_power_on(std::function<void()> on_power_on);
+    void set_callback_on_power_off(std::function<void()> on_power_off);
+
+    void scan_start();
+    void scan_stop();
+    void scan_for(int timeout_ms);
+    bool scan_is_active();
+    std::vector<Peripheral> scan_get_results();
+
+    void set_callback_on_scan_start(std::function<void()> on_scan_start);
+    void set_callback_on_scan_stop(std::function<void()> on_scan_stop);
+    void set_callback_on_scan_updated(std::function<void(Peripheral)> on_scan_updated);
+    void set_callback_on_scan_found(std::function<void(Peripheral)> on_scan_found);
+
+    /**
+     * Retrieve a list of all paired peripherals.
+     *
+     * NOTE:This method is currently only supported by the Linux, Windows and Android backends.
+     */
+    std::vector<Peripheral> get_paired_peripherals();
+
+    /**
+     * Retrieve a list of all connected peripherals.
+     *
+     * NOTE: This method is currently only supported by the Windows backend. (More backends coming soon.)
+     */
+    std::vector<Peripheral> get_connected_peripherals();
+
+    static bool bluetooth_enabled();
+
+    /**
+     * Fetches a list of all available adapters from all available backends.
+     *
+     * This will cause backends to be instantiated/initialized and adapters
+     * too.
+     */
+    static std::vector<Adapter> get_adapters();
+
+  protected:
+    AdapterBase* operator->();
+    const AdapterBase* operator->() const;
+
+    std::shared_ptr<AdapterBase> internal_;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/install_simplecble/include/simpleble/AdapterSafe.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <simpleble/export.h>
+
+#include <simpleble/Adapter.h>
+#include <simpleble/PeripheralSafe.h>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace SimpleBLE {
+
+namespace Safe {
+
+/**
+ * Wrapper around the Adapter class that provides a noexcept interface.
+ *
+ * We use instances of this class directly and not through shared_ptr because
+ * this is just a wrapper around the Adapter class, which is already managed by
+ * shared_ptr.
+ */
+class SIMPLEBLE_EXPORT Adapter {
+  public:
+    Adapter(SimpleBLE::Adapter& adapter);
+    Adapter(SimpleBLE::Adapter&& adapter);
+    virtual ~Adapter() = default;
+
+    std::optional<std::string> identifier() noexcept;
+    std::optional<BluetoothAddress> address() noexcept;
+
+    bool scan_start() noexcept;
+    bool scan_stop() noexcept;
+    bool scan_for(int timeout_ms) noexcept;
+    std::optional<bool> scan_is_active() noexcept;
+    std::optional<std::vector<SimpleBLE::Safe::Peripheral>> scan_get_results() noexcept;
+
+    bool set_callback_on_scan_start(std::function<void()> on_scan_start) noexcept;
+    bool set_callback_on_scan_stop(std::function<void()> on_scan_stop) noexcept;
+    bool set_callback_on_scan_updated(std::function<void(SimpleBLE::Safe::Peripheral)> on_scan_updated) noexcept;
+    bool set_callback_on_scan_found(std::function<void(SimpleBLE::Safe::Peripheral)> on_scan_found) noexcept;
+
+    std::optional<std::vector<SimpleBLE::Safe::Peripheral>> get_paired_peripherals() noexcept;
+
+    static std::optional<bool> bluetooth_enabled() noexcept;
+    static std::optional<std::vector<SimpleBLE::Safe::Adapter>> get_adapters() noexcept;
+
+    /**
+     * Cast to the underlying adapter object.
+     */
+    operator SimpleBLE::Adapter() const noexcept;
+
+  protected:
+    SimpleBLE::Adapter internal_;
+};
+
+}  // namespace Safe
+
+}  // namespace SimpleBLE

data/vendor/simpleble/install_simplecble/include/simpleble/Advanced.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <simpleble/export.h>
+
+#if __APPLE__
+#include "TargetConditionals.h"
+#endif
+
+/**
+ * Advanced Features
+ *
+ * The functions presented in this namespace are OS-specific backdoors that are
+ * not part of the standard SimpleBLE API, which allow the user to access
+ * low-level details of the implementation for advanced use cases.
+ *
+ * These functions should be used with caution.
+ */
+
+#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 <jni.h>
+
+namespace SimpleBLE::Advanced::Android {
+
+JavaVM* SIMPLEBLE_EXPORT get_jvm();
+void SIMPLEBLE_EXPORT set_jvm(JavaVM* jvm);
+
+}  // namespace SimpleBLE::Advanced::Android
+
+#endif
+
+#if defined(__linux__) && !defined(__ANDROID__)
+namespace SimpleBLE::Advanced::Linux {}
+
+#endif

data/vendor/simpleble/install_simplecble/include/simpleble/Characteristic.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Descriptor.h>
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class CharacteristicBase;
+
+class SIMPLEBLE_EXPORT Characteristic {
+  public:
+    Characteristic() = default;
+    virtual ~Characteristic() = default;
+
+    bool initialized() const;
+
+    BluetoothUUID uuid();
+    std::vector<Descriptor> descriptors();
+    std::vector<std::string> capabilities();
+
+    bool can_read();
+    bool can_write_request();
+    bool can_write_command();
+    bool can_notify();
+    bool can_indicate();
+
+  protected:
+    CharacteristicBase* operator->();
+    const CharacteristicBase* operator->() const;
+
+    std::shared_ptr<CharacteristicBase> internal_;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/install_simplecble/include/simpleble/Config.h

@@ -0,0 +1,55 @@
+#pragma once
+#include <chrono>
+
+namespace SimpleBLE {
+namespace Config {
+    namespace SimpleBluez {
+        inline static std::chrono::steady_clock::duration connection_timeout = std::chrono::seconds(2);
+        inline static std::chrono::steady_clock::duration disconnection_timeout = std::chrono::seconds(1);
+
+        static void reset() {
+            connection_timeout = std::chrono::seconds(2);
+            disconnection_timeout = std::chrono::seconds(1);
+        }
+    }
+
+    namespace WinRT {
+        inline static bool experimental_use_own_mta_apartment = true;
+        inline static bool experimental_reinitialize_winrt_apartment_on_main_thread = false;
+
+        static void reset() {
+            experimental_use_own_mta_apartment = true;
+            experimental_reinitialize_winrt_apartment_on_main_thread = false;
+        }
+    }
+
+    namespace CoreBluetooth {
+        static void reset() {}
+    }
+
+    namespace Android {
+        enum class ConnectionPriorityRequest {
+            DISABLED = -1,
+            BALANCED = 0,
+            HIGH = 1,
+            LOW_POWER = 2,
+            DCK = 3
+        };
+
+        inline static ConnectionPriorityRequest connection_priority_request = ConnectionPriorityRequest::DISABLED;
+
+        static void reset() {
+            connection_priority_request = ConnectionPriorityRequest::DISABLED;
+        }
+    }
+
+    namespace Base {
+        static void reset_all() {
+            SimpleBluez::reset();
+            WinRT::reset();
+            CoreBluetooth::reset();
+            Android::reset();
+        }
+    }
+}  // namespace Config
+}  // namespace SimpleBLE

data/vendor/simpleble/install_simplecble/include/simpleble/Descriptor.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class DescriptorBase;
+
+class SIMPLEBLE_EXPORT Descriptor {
+  public:
+    Descriptor() = default;
+    virtual ~Descriptor() = default;
+
+    bool initialized() const;
+
+    BluetoothUUID uuid();
+
+  protected:
+    DescriptorBase* operator->();
+    const DescriptorBase* operator->() const;
+
+    std::shared_ptr<DescriptorBase> internal_;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/install_simplecble/include/simpleble/Exceptions.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+#include <simpleble/export.h>
+
+#include "Types.h"
+
+namespace SimpleBLE {
+
+namespace Exception {
+
+class SIMPLEBLE_EXPORT BaseException : public std::runtime_error {
+  public:
+    BaseException(const std::string& __arg) : std::runtime_error(__arg) {}
+};
+
+class SIMPLEBLE_EXPORT NotInitialized : public BaseException {
+  public:
+    NotInitialized();
+};
+
+class SIMPLEBLE_EXPORT NotConnected : public BaseException {
+  public:
+    NotConnected();
+};
+
+class SIMPLEBLE_EXPORT InvalidReference : public BaseException {
+  public:
+    InvalidReference();
+};
+
+class SIMPLEBLE_EXPORT ServiceNotFound : public BaseException {
+  public:
+    ServiceNotFound(BluetoothUUID uuid);
+};
+
+class SIMPLEBLE_EXPORT CharacteristicNotFound : public BaseException {
+  public:
+    CharacteristicNotFound(BluetoothUUID uuid);
+};
+
+class SIMPLEBLE_EXPORT DescriptorNotFound : public BaseException {
+  public:
+    DescriptorNotFound(BluetoothUUID uuid);
+};
+
+class SIMPLEBLE_EXPORT OperationNotSupported : public BaseException {
+  public:
+    OperationNotSupported();
+};
+
+class SIMPLEBLE_EXPORT OperationFailed : public BaseException {
+  public:
+    OperationFailed();
+    OperationFailed(const std::string& err_msg);
+};
+
+class SIMPLEBLE_EXPORT WinRTException : public BaseException {
+  public:
+    WinRTException(int32_t err_code, const std::string& err_msg);
+};
+
+class SIMPLEBLE_EXPORT CoreBluetoothException : public BaseException {
+  public:
+    CoreBluetoothException(const std::string& err_msg);
+};
+
+}  // namespace Exception
+
+}  // namespace SimpleBLE