simpleble 0.0.1

data/vendor/simpleble/simplebluez/test/src/main.cpp

@@ -0,0 +1,16 @@
+
+#include <gtest/gtest.h>
+#include "helpers/PythonRunner.h"
+
+int main(int argc, char** argv) {
+    PythonRunner runner("test_fixture.py");
+
+    runner.init();
+
+    ::testing::InitGoogleTest(&argc, argv);
+    auto test_result = RUN_ALL_TESTS();
+
+    runner.uninit();
+
+    return test_result;
+}

data/vendor/simpleble/simplecble/include/simplecble/adapter.h

@@ -0,0 +1,188 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <simpleble/export.h>
+
+#include <simpleble_c/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief
+ *
+ * @return bool
+ */
+SIMPLEBLE_EXPORT bool simpleble_adapter_is_bluetooth_enabled(void);
+
+/**
+ * @brief
+ *
+ * @return size_t
+ */
+SIMPLEBLE_EXPORT size_t simpleble_adapter_get_count(void);
+
+/**
+ * @brief
+ *
+ * @note The user is responsible for freeing the returned adapter object
+ *       by calling `simpleble_adapter_release_handle`.
+ *
+ * @param index
+ * @return simpleble_adapter_t
+ */
+SIMPLEBLE_EXPORT simpleble_adapter_t simpleble_adapter_get_handle(size_t index);
+
+/**
+ * @brief Releases all memory and resources consumed by the specific
+ *        instance of simpleble_adapter_t.
+ *
+ * @param handle
+ */
+SIMPLEBLE_EXPORT void simpleble_adapter_release_handle(simpleble_adapter_t handle);
+
+/**
+ * @brief Returns the identifier of a given adapter.
+ *
+ * @note The user is responsible for freeing the returned value.
+ *
+ * @param handle
+ * @return char*
+ */
+SIMPLEBLE_EXPORT char* simpleble_adapter_identifier(simpleble_adapter_t handle);
+
+/**
+ * @brief Returns the MAC address of a given adapter.
+ *
+ * @note The user is responsible for freeing the returned value.
+ *
+ * @param handle
+ * @return char*
+ */
+SIMPLEBLE_EXPORT char* simpleble_adapter_address(simpleble_adapter_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_scan_start(simpleble_adapter_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_scan_stop(simpleble_adapter_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param active
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_scan_is_active(simpleble_adapter_t handle, bool* active);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param timeout_ms
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_scan_for(simpleble_adapter_t handle, int timeout_ms);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return size_t
+ */
+SIMPLEBLE_EXPORT size_t simpleble_adapter_scan_get_results_count(simpleble_adapter_t handle);
+
+/**
+ * @brief
+ *
+ * @note The user is responsible for freeing the returned peripheral object
+ *       by calling `simpleble_peripheral_release_handle`.
+ *
+ * @param handle
+ * @param index
+ * @return simpleble_peripheral_t
+ */
+SIMPLEBLE_EXPORT simpleble_peripheral_t simpleble_adapter_scan_get_results_handle(simpleble_adapter_t handle,
+                                                                                  size_t index);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return size_t
+ */
+SIMPLEBLE_EXPORT size_t simpleble_adapter_get_paired_peripherals_count(simpleble_adapter_t handle);
+
+/**
+ * @brief
+ *
+ * @note The user is responsible for freeing the returned peripheral object
+ *       by calling `simpleble_peripheral_release_handle`.
+ *
+ * @param handle
+ * @param index
+ * @return simpleble_peripheral_t
+ */
+SIMPLEBLE_EXPORT simpleble_peripheral_t simpleble_adapter_get_paired_peripherals_handle(simpleble_adapter_t handle,
+                                                                                        size_t index);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_set_callback_on_scan_start(
+    simpleble_adapter_t handle, void (*callback)(simpleble_adapter_t adapter, void* userdata), void* userdata);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_set_callback_on_scan_stop(
+    simpleble_adapter_t handle, void (*callback)(simpleble_adapter_t adapter, void* userdata), void* userdata);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_set_callback_on_scan_updated(
+    simpleble_adapter_t handle,
+    void (*callback)(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata), void* userdata);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_adapter_set_callback_on_scan_found(
+    simpleble_adapter_t handle,
+    void (*callback)(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata), void* userdata);
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/simpleble/simplecble/include/simplecble/logging.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <stdint.h>
+
+#include <simpleble/export.h>
+
+typedef enum {
+    SIMPLEBLE_LOG_LEVEL_NONE = 0,
+    SIMPLEBLE_LOG_LEVEL_FATAL,
+    SIMPLEBLE_LOG_LEVEL_ERROR,
+    SIMPLEBLE_LOG_LEVEL_WARN,
+    SIMPLEBLE_LOG_LEVEL_INFO,
+    SIMPLEBLE_LOG_LEVEL_DEBUG,
+    SIMPLEBLE_LOG_LEVEL_VERBOSE
+} simpleble_log_level_t;
+
+// clang-format off
+typedef void (*simpleble_log_callback_t)(
+    simpleble_log_level_t level,
+    const char* module,
+    const char* file,
+    uint32_t line,
+    const char* function,
+    const char* message
+);
+// clang-format on
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SIMPLEBLE_EXPORT void simpleble_logging_set_level(simpleble_log_level_t level);
+SIMPLEBLE_EXPORT void simpleble_logging_set_callback(simpleble_log_callback_t callback);
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/simpleble/simplecble/include/simplecble/peripheral.h

@@ -0,0 +1,304 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <simpleble/export.h>
+
+#include <simpleble_c/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Releases all memory and resources consumed by the specific
+ *        instance of simpleble_peripheral_t.
+ *
+ * @param handle
+ */
+SIMPLEBLE_EXPORT void simpleble_peripheral_release_handle(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return char*
+ */
+SIMPLEBLE_EXPORT char* simpleble_peripheral_identifier(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return char*
+ */
+SIMPLEBLE_EXPORT char* simpleble_peripheral_address(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return simpleble_address_type_t
+ */
+SIMPLEBLE_EXPORT simpleble_address_type_t simpleble_peripheral_address_type(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return int16_t
+ */
+SIMPLEBLE_EXPORT int16_t simpleble_peripheral_rssi(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return int16_t
+ */
+SIMPLEBLE_EXPORT int16_t simpleble_peripheral_tx_power(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return uint16_t
+ */
+SIMPLEBLE_EXPORT uint16_t simpleble_peripheral_mtu(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_connect(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_disconnect(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param connected
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_is_connected(simpleble_peripheral_t handle, bool* connected);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param connectable
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_is_connectable(simpleble_peripheral_t handle, bool* connectable);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param paired
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_is_paired(simpleble_peripheral_t handle, bool* paired);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_unpair(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return size_t
+ */
+SIMPLEBLE_EXPORT size_t simpleble_peripheral_services_count(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param index
+ * @param services
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_services_get(simpleble_peripheral_t handle, size_t index,
+                                                                   simpleble_service_t* services);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @return size_t
+ */
+SIMPLEBLE_EXPORT size_t simpleble_peripheral_manufacturer_data_count(simpleble_peripheral_t handle);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param index
+ * @param manufacturer_data
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_manufacturer_data_get(
+    simpleble_peripheral_t handle, size_t index, simpleble_manufacturer_data_t* manufacturer_data);
+
+/**
+ * @brief
+ *
+ * @note The user is responsible for freeing the pointer returned in data.
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @param data
+ * @param data_length
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_read(simpleble_peripheral_t handle, simpleble_uuid_t service,
+                                                           simpleble_uuid_t characteristic, uint8_t** data,
+                                                           size_t* data_length);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @param data
+ * @param data_length
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_write_request(simpleble_peripheral_t handle,
+                                                                    simpleble_uuid_t service,
+                                                                    simpleble_uuid_t characteristic,
+                                                                    const uint8_t* data, size_t data_length);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @param data
+ * @param data_length
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_write_command(simpleble_peripheral_t handle,
+                                                                    simpleble_uuid_t service,
+                                                                    simpleble_uuid_t characteristic,
+                                                                    const uint8_t* data, size_t data_length);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_notify(
+    simpleble_peripheral_t handle, simpleble_uuid_t service, simpleble_uuid_t characteristic,
+    void (*callback)(simpleble_peripheral_t handle, simpleble_uuid_t service, simpleble_uuid_t characteristic,
+                     const uint8_t* data, size_t data_length, void* userdata),
+    void* userdata);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_indicate(
+    simpleble_peripheral_t handle, simpleble_uuid_t service, simpleble_uuid_t characteristic,
+    void (*callback)(simpleble_peripheral_t handle, simpleble_uuid_t service, simpleble_uuid_t characteristic,
+                     const uint8_t* data, size_t data_length, void* userdata),
+    void* userdata);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_unsubscribe(simpleble_peripheral_t handle,
+                                                                  simpleble_uuid_t service,
+                                                                  simpleble_uuid_t characteristic);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @param descriptor
+ * @param data
+ * @param data_length
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_read_descriptor(simpleble_peripheral_t handle,
+                                                                      simpleble_uuid_t service,
+                                                                      simpleble_uuid_t characteristic,
+                                                                      simpleble_uuid_t descriptor, uint8_t** data,
+                                                                      size_t* data_length);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param service
+ * @param characteristic
+ * @param descriptor
+ * @param data
+ * @param data_length
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_write_descriptor(simpleble_peripheral_t handle,
+                                                                       simpleble_uuid_t service,
+                                                                       simpleble_uuid_t characteristic,
+                                                                       simpleble_uuid_t descriptor, const uint8_t* data,
+                                                                       size_t data_length);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_set_callback_on_connected(
+    simpleble_peripheral_t handle, void (*callback)(simpleble_peripheral_t peripheral, void* userdata), void* userdata);
+
+/**
+ * @brief
+ *
+ * @param handle
+ * @param callback
+ * @return simpleble_err_t
+ */
+SIMPLEBLE_EXPORT simpleble_err_t simpleble_peripheral_set_callback_on_disconnected(
+    simpleble_peripheral_t handle, void (*callback)(simpleble_peripheral_t peripheral, void* userdata), void* userdata);
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/simpleble/simplecble/include/simplecble/simpleble.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <simpleble/export.h>
+#include <simpleble_c/adapter.h>
+#include <simpleble_c/peripheral.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Wrapper around free() to allow memory to be cleared
+ *        within the library.
+ *
+ * @param handle
+ */
+SIMPLEBLE_EXPORT void simpleble_free(void* handle);
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/simpleble/simplecble/include/simplecble/types.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#define SIMPLEBLE_UUID_STR_LEN 37  // 36 characters + null terminator
+#define SIMPLEBLE_CHARACTERISTIC_MAX_COUNT 16
+#define SIMPLEBLE_DESCRIPTOR_MAX_COUNT 16
+
+// TODO: Add proper error codes.
+typedef enum {
+    SIMPLEBLE_SUCCESS = 0,
+    SIMPLEBLE_FAILURE = 1,
+} simpleble_err_t;
+
+typedef struct {
+    char value[SIMPLEBLE_UUID_STR_LEN];
+} simpleble_uuid_t;
+
+typedef struct {
+    simpleble_uuid_t uuid;
+} simpleble_descriptor_t;
+
+typedef struct {
+    simpleble_uuid_t uuid;
+    bool can_read;
+    bool can_write_request;
+    bool can_write_command;
+    bool can_notify;
+    bool can_indicate;
+    size_t descriptor_count;
+    simpleble_descriptor_t descriptors[SIMPLEBLE_DESCRIPTOR_MAX_COUNT];
+} simpleble_characteristic_t;
+
+typedef struct {
+    simpleble_uuid_t uuid;
+    size_t data_length;
+    uint8_t data[27];
+    // Note: The maximum length of a BLE advertisement is 31 bytes.
+    // The first byte will be the length of the field,
+    // the second byte will be the type of the field,
+    // the next two bytes will be the service UUID,
+    // and the remaining 27 bytes are the manufacturer data.
+    size_t characteristic_count;
+    simpleble_characteristic_t characteristics[SIMPLEBLE_CHARACTERISTIC_MAX_COUNT];
+} simpleble_service_t;
+
+typedef struct {
+    uint16_t manufacturer_id;
+    size_t data_length;
+    uint8_t data[27];
+    // Note: The maximum length of a BLE advertisement is 31 bytes.
+    // The first byte will be the length of the field,
+    // the second byte will be the type of the field (0xFF for manufacturer data),
+    // the next two bytes will be the manufacturer ID,
+    // and the remaining 27 bytes are the manufacturer data.
+} simpleble_manufacturer_data_t;
+
+typedef void* simpleble_adapter_t;
+typedef void* simpleble_peripheral_t;
+
+typedef enum {
+    SIMPLEBLE_OS_WINDOWS = 0,
+    SIMPLEBLE_OS_MACOS = 1,
+    SIMPLEBLE_OS_LINUX = 2,
+} simpleble_os_t;
+
+typedef enum {
+    SIMPLEBLE_ADDRESS_TYPE_PUBLIC = 0,
+    SIMPLEBLE_ADDRESS_TYPE_RANDOM = 1,
+    SIMPLEBLE_ADDRESS_TYPE_UNSPECIFIED = 2,
+} simpleble_address_type_t;

data/vendor/simpleble/simplecble/include/simplecble/utils.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <simpleble/export.h>
+
+#include <simpleble_c/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Returns the operating system on which SimpleBLE library is currently running.
+ *
+ * @return A simpleble_os_t value representing the current operating system.
+ */
+SIMPLEBLE_EXPORT simpleble_os_t simpleble_get_operating_system(void);
+
+/**
+ * Returns a string representing the version of the SimpleBLE library.
+ *
+ * @return A const char pointer to the version string.
+ */
+SIMPLEBLE_EXPORT const char* simpleble_get_version(void);
+
+#ifdef __cplusplus
+}
+#endif