simpleble 0.0.1

data/vendor/simpleble/simplecble/src/adapter.cpp

@@ -0,0 +1,204 @@
+#include <simpleble_c/adapter.h>
+
+#include <simpleble/AdapterSafe.h>
+
+#include <cstring>
+
+bool simpleble_adapter_is_bluetooth_enabled(void) {
+    return SimpleBLE::Safe::Adapter::bluetooth_enabled().value_or(false);
+}
+
+size_t simpleble_adapter_get_count(void) {
+    return SimpleBLE::Safe::Adapter::get_adapters().value_or(std::vector<SimpleBLE::Safe::Adapter>()).size();
+}
+
+simpleble_adapter_t simpleble_adapter_get_handle(size_t index) {
+    auto adapter_list = SimpleBLE::Safe::Adapter::get_adapters().value_or(std::vector<SimpleBLE::Safe::Adapter>());
+
+    if (index >= adapter_list.size()) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Adapter* handle = new SimpleBLE::Safe::Adapter(adapter_list[index]);
+    return handle;
+}
+
+void simpleble_adapter_release_handle(simpleble_adapter_t handle) {
+    if (handle == nullptr) {
+        return;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    delete adapter;
+}
+
+char* simpleble_adapter_identifier(simpleble_adapter_t handle) {
+    if (handle == nullptr) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    std::string identifier = adapter->identifier().value_or("");
+    char* c_identifier = (char*)malloc(identifier.size() + 1);
+    strcpy(c_identifier, identifier.c_str());
+    return c_identifier;
+}
+
+char* simpleble_adapter_address(simpleble_adapter_t handle) {
+    if (handle == nullptr) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    std::string address = adapter->address().value_or("");
+    char* c_address = (char*)malloc(address.size() + 1);
+    strcpy(c_address, address.c_str());
+    return c_address;
+}
+
+simpleble_err_t simpleble_adapter_scan_start(simpleble_adapter_t handle) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    return adapter->scan_start() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_adapter_scan_stop(simpleble_adapter_t handle) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    return adapter->scan_stop() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_adapter_scan_is_active(simpleble_adapter_t handle, bool* active) {
+    if (handle == nullptr || active == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+
+    std::optional<bool> is_active = adapter->scan_is_active();
+    *active = is_active.value_or(false);
+    return is_active.has_value() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_adapter_scan_for(simpleble_adapter_t handle, int timeout_ms) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    return adapter->scan_for(timeout_ms) ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+size_t simpleble_adapter_scan_get_results_count(simpleble_adapter_t handle) {
+    if (handle == nullptr) {
+        return 0;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    return adapter->scan_get_results().value_or(std::vector<SimpleBLE::Safe::Peripheral>()).size();
+}
+
+simpleble_peripheral_t simpleble_adapter_scan_get_results_handle(simpleble_adapter_t handle, size_t index) {
+    if (handle == nullptr) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    auto results = adapter->scan_get_results().value_or(std::vector<SimpleBLE::Safe::Peripheral>());
+
+    if (index >= results.size()) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral_handle = new SimpleBLE::Safe::Peripheral(results[index]);
+    return peripheral_handle;
+}
+
+size_t simpleble_adapter_get_paired_peripherals_count(simpleble_adapter_t handle) {
+    if (handle == nullptr) {
+        return 0;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    return adapter->get_paired_peripherals().value_or(std::vector<SimpleBLE::Safe::Peripheral>()).size();
+}
+
+simpleble_peripheral_t simpleble_adapter_get_paired_peripherals_handle(simpleble_adapter_t handle, size_t index) {
+    if (handle == nullptr) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+    auto results = adapter->get_paired_peripherals().value_or(std::vector<SimpleBLE::Safe::Peripheral>());
+
+    if (index >= results.size()) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral_handle = new SimpleBLE::Safe::Peripheral(results[index]);
+    return peripheral_handle;
+}
+
+simpleble_err_t simpleble_adapter_set_callback_on_scan_start(simpleble_adapter_t handle,
+                                                             void (*callback)(simpleble_adapter_t, void*),
+                                                             void* userdata) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+
+    bool success = adapter->set_callback_on_scan_start([=]() { callback(handle, userdata); });
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_adapter_set_callback_on_scan_stop(simpleble_adapter_t handle,
+                                                            void (*callback)(simpleble_adapter_t, void*),
+                                                            void* userdata) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+
+    bool success = adapter->set_callback_on_scan_stop([=]() { callback(handle, userdata); });
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_adapter_set_callback_on_scan_updated(
+    simpleble_adapter_t handle, void (*callback)(simpleble_adapter_t, simpleble_peripheral_t, void*), void* userdata) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+
+    bool success = adapter->set_callback_on_scan_updated([=](SimpleBLE::Safe::Peripheral peripheral) {
+        // Create a peripheral handle
+        SimpleBLE::Safe::Peripheral* peripheral_handle = new SimpleBLE::Safe::Peripheral(peripheral);
+        callback(handle, peripheral_handle, userdata);
+    });
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_adapter_set_callback_on_scan_found(
+    simpleble_adapter_t handle, void (*callback)(simpleble_adapter_t, simpleble_peripheral_t, void*), void* userdata) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Adapter* adapter = (SimpleBLE::Safe::Adapter*)handle;
+
+    bool success = adapter->set_callback_on_scan_found([=](SimpleBLE::Safe::Peripheral peripheral) {
+        // Create a peripheral handle
+        SimpleBLE::Safe::Peripheral* peripheral_handle = new SimpleBLE::Safe::Peripheral(peripheral);
+        callback(handle, peripheral_handle, userdata);
+    });
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}

data/vendor/simpleble/simplecble/src/logging.cpp

@@ -0,0 +1,19 @@
+#include <simpleble/Logging.h>
+#include <simpleble_c/logging.h>
+
+void simpleble_logging_set_level(simpleble_log_level_t level) {
+    SimpleBLE::Logging::Logger::get()->set_level(static_cast<SimpleBLE::Logging::Level>(level));
+}
+
+void simpleble_logging_set_callback(simpleble_log_callback_t callback) {
+    SimpleBLE::Logging::Logger::get()->set_callback(
+        [callback](SimpleBLE::Logging::Level level, const std::string& module, const std::string& file, uint32_t line,
+                   const std::string& function, const std::string& message) {
+            try {
+                callback(static_cast<simpleble_log_level_t>(level), module.c_str(), file.c_str(), line,
+                         function.c_str(), message.c_str());
+            } catch (...) {
+                // Clearly, if the logging callback throws an exception, we should not crash.
+            }
+        });
+}

data/vendor/simpleble/simplecble/src/peripheral.cpp

@@ -0,0 +1,444 @@
+#include <simpleble_c/peripheral.h>
+
+#include <simpleble/PeripheralSafe.h>
+
+#include <climits>
+#include <cstring>
+#include <map>
+
+void simpleble_peripheral_release_handle(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    delete peripheral;
+}
+
+char* simpleble_peripheral_identifier(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    std::string identifier = peripheral->identifier().value_or("");
+    char* c_identifier = (char*)malloc(identifier.size() + 1);
+    strcpy(c_identifier, identifier.c_str());
+    return c_identifier;
+}
+
+char* simpleble_peripheral_address(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return nullptr;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    std::string address = peripheral->address().value_or("");
+    char* c_address = (char*)malloc(address.size() + 1);
+    strcpy(c_address, address.c_str());
+    return c_address;
+}
+
+simpleble_address_type_t simpleble_peripheral_address_type(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_ADDRESS_TYPE_UNSPECIFIED;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    SimpleBLE::BluetoothAddressType address_type = peripheral->address_type().value_or(
+        SimpleBLE::BluetoothAddressType::UNSPECIFIED);
+    return (simpleble_address_type_t)address_type;
+}
+
+int16_t simpleble_peripheral_rssi(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return INT16_MIN;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    return peripheral->rssi().value_or(INT16_MIN);
+}
+
+int16_t simpleble_peripheral_tx_power(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return INT16_MIN;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    return peripheral->tx_power().value_or(INT16_MIN);
+}
+
+uint16_t simpleble_peripheral_mtu(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return 0;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    return peripheral->mtu().value_or(0);
+}
+
+simpleble_err_t simpleble_peripheral_connect(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    return peripheral->connect() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_disconnect(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    return peripheral->disconnect() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_is_connected(simpleble_peripheral_t handle, bool* connected) {
+    if (handle == nullptr || connected == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    std::optional<bool> is_connected = peripheral->is_connected();
+    *connected = is_connected.value_or(false);
+    return is_connected.has_value() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_is_connectable(simpleble_peripheral_t handle, bool* connectable) {
+    if (handle == nullptr || connectable == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    std::optional<bool> is_connectable = peripheral->is_connectable();
+    *connectable = is_connectable.value_or(false);
+    return is_connectable.has_value() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_is_paired(simpleble_peripheral_t handle, bool* paired) {
+    if (handle == nullptr || paired == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    std::optional<bool> is_paired = peripheral->is_paired();
+    *paired = is_paired.value_or(false);
+    return is_paired.has_value() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_unpair(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    return peripheral->unpair() ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+size_t simpleble_peripheral_services_count(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return 0;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    auto services = peripheral->services();
+    if (services.has_value()) {
+        return services.value().size();
+    } else {
+        return 0;
+    }
+}
+
+simpleble_err_t simpleble_peripheral_services_get(simpleble_peripheral_t handle, size_t index,
+                                                  simpleble_service_t* services) {
+    if (handle == nullptr || services == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    memset(services, 0, sizeof(simpleble_service_t));
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    auto peripheral_services = peripheral->services();
+    if (!peripheral_services.has_value()) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    if (index >= peripheral_services.value().size()) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Service service = peripheral_services.value()[index];
+
+    memcpy(services->uuid.value, service.uuid().c_str(), SIMPLEBLE_UUID_STR_LEN);
+
+    services->data_length = service.data().size();
+    memcpy(services->data, service.data().data(), service.data().size());
+
+    services->characteristic_count = service.characteristics().size();
+    if (services->characteristic_count > SIMPLEBLE_CHARACTERISTIC_MAX_COUNT) {
+        services->characteristic_count = SIMPLEBLE_CHARACTERISTIC_MAX_COUNT;
+    }
+
+    for (size_t i = 0; i < services->characteristic_count; i++) {
+        SimpleBLE::Characteristic characteristic = service.characteristics()[i];
+
+        services->characteristics[i].can_read = characteristic.can_read();
+        services->characteristics[i].can_write_request = characteristic.can_write_request();
+        services->characteristics[i].can_write_command = characteristic.can_write_command();
+        services->characteristics[i].can_notify = characteristic.can_notify();
+        services->characteristics[i].can_indicate = characteristic.can_indicate();
+
+        memcpy(services->characteristics[i].uuid.value, characteristic.uuid().c_str(), SIMPLEBLE_UUID_STR_LEN);
+        services->characteristics[i].descriptor_count = characteristic.descriptors().size();
+
+        if (services->characteristics[i].descriptor_count > SIMPLEBLE_DESCRIPTOR_MAX_COUNT) {
+            services->characteristics[i].descriptor_count = SIMPLEBLE_DESCRIPTOR_MAX_COUNT;
+        }
+
+        for (size_t j = 0; j < services->characteristics[i].descriptor_count; j++) {
+            SimpleBLE::Descriptor descriptor = characteristic.descriptors()[j];
+
+            memcpy(services->characteristics[i].descriptors[j].uuid.value, descriptor.uuid().c_str(),
+                   SIMPLEBLE_UUID_STR_LEN);
+        }
+    }
+
+    return SIMPLEBLE_SUCCESS;
+}
+
+size_t simpleble_peripheral_manufacturer_data_count(simpleble_peripheral_t handle) {
+    if (handle == nullptr) {
+        return 0;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    auto manufacturer_data = peripheral->manufacturer_data();
+    if (manufacturer_data.has_value()) {
+        return manufacturer_data.value().size();
+    } else {
+        return 0;
+    }
+}
+
+simpleble_err_t simpleble_peripheral_manufacturer_data_get(simpleble_peripheral_t handle, size_t index,
+                                                           simpleble_manufacturer_data_t* manufacturer_data) {
+    if (handle == nullptr || manufacturer_data == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    auto peripheral_manufacturer_data = peripheral->manufacturer_data();
+    if (!peripheral_manufacturer_data.has_value()) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    if (index >= peripheral_manufacturer_data.value().size()) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    // Build an iterator and advance to the expected element
+    std::map<uint16_t, SimpleBLE::ByteArray>::iterator it = peripheral_manufacturer_data.value().begin();
+    for (size_t i = 0; i < index; i++) {
+        it++;
+    }
+
+    auto& selected_manufacturer_data = *it;
+    manufacturer_data->manufacturer_id = selected_manufacturer_data.first;
+    manufacturer_data->data_length = selected_manufacturer_data.second.size();
+    memcpy(manufacturer_data->data, selected_manufacturer_data.second.data(), selected_manufacturer_data.second.size());
+
+    return SIMPLEBLE_SUCCESS;
+}
+
+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) {
+    if (handle == nullptr || data == nullptr || data_length == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    // Clear the initial values for safety
+    *data = nullptr;
+    *data_length = 0;
+
+    // Perform the read operation
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    std::optional<SimpleBLE::ByteArray> read_data = peripheral->read(SimpleBLE::BluetoothUUID(service.value),
+                                                                     SimpleBLE::BluetoothUUID(characteristic.value));
+
+    // Early return if the operation failed
+    if (!read_data.has_value()) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    *data_length = read_data.value().size();
+    *data = static_cast<uint8_t*>(malloc(*data_length));
+    memcpy(*data, read_data.value().data(), *data_length);
+
+    return SIMPLEBLE_SUCCESS;
+}
+
+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) {
+    if (handle == nullptr || data == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->write_request(SimpleBLE::BluetoothUUID(service.value),
+                                             SimpleBLE::BluetoothUUID(characteristic.value),
+                                             SimpleBLE::ByteArray((const char*)data, data_length));
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+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) {
+    if (handle == nullptr || data == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->write_command(SimpleBLE::BluetoothUUID(service.value),
+                                             SimpleBLE::BluetoothUUID(characteristic.value),
+                                             SimpleBLE::ByteArray((const char*)data, data_length));
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_notify(simpleble_peripheral_t handle, simpleble_uuid_t service,
+                                            simpleble_uuid_t characteristic,
+                                            void (*callback)(simpleble_peripheral_t, simpleble_uuid_t, simpleble_uuid_t,
+                                                             const uint8_t*, size_t, void*),
+                                            void* userdata) {
+    if (handle == nullptr || callback == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->notify(SimpleBLE::BluetoothUUID(service.value),
+                                      SimpleBLE::BluetoothUUID(characteristic.value), [=](SimpleBLE::ByteArray data) {
+                                          callback(handle, service, characteristic, (const uint8_t*)data.data(),
+                                                   data.size(), userdata);
+                                      });
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_indicate(simpleble_peripheral_t handle, simpleble_uuid_t service,
+                                              simpleble_uuid_t characteristic,
+                                              void (*callback)(simpleble_peripheral_t, simpleble_uuid_t,
+                                                               simpleble_uuid_t, const uint8_t*, size_t, void*),
+                                              void* userdata) {
+    if (handle == nullptr || callback == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->indicate(SimpleBLE::BluetoothUUID(service.value),
+                                        SimpleBLE::BluetoothUUID(characteristic.value), [=](SimpleBLE::ByteArray data) {
+                                            callback(handle, service, characteristic, (const uint8_t*)data.data(),
+                                                     data.size(), userdata);
+                                        });
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_unsubscribe(simpleble_peripheral_t handle, simpleble_uuid_t service,
+                                                 simpleble_uuid_t characteristic) {
+    if (handle == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->unsubscribe(SimpleBLE::BluetoothUUID(service.value),
+                                           SimpleBLE::BluetoothUUID(characteristic.value));
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+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) {
+    if (handle == nullptr || data == nullptr || data_length == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    // Clear the initial values for safety
+    *data = nullptr;
+    *data_length = 0;
+
+    // Perform the read operation
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+    std::optional<SimpleBLE::ByteArray> read_data = peripheral->read(SimpleBLE::BluetoothUUID(service.value),
+                                                                     SimpleBLE::BluetoothUUID(characteristic.value),
+                                                                     SimpleBLE::BluetoothUUID(descriptor.value));
+
+    // Early return if the operation failed
+    if (!read_data.has_value()) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    *data_length = read_data.value().size();
+    *data = static_cast<uint8_t*>(malloc(*data_length));
+    memcpy(*data, read_data.value().data(), *data_length);
+
+    return SIMPLEBLE_SUCCESS;
+}
+
+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) {
+    if (handle == nullptr || data == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->write(
+        SimpleBLE::BluetoothUUID(service.value), SimpleBLE::BluetoothUUID(characteristic.value),
+        SimpleBLE::BluetoothUUID(descriptor.value), SimpleBLE::ByteArray((const char*)data, data_length));
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_set_callback_on_connected(simpleble_peripheral_t handle,
+                                                               void (*callback)(simpleble_peripheral_t, void*),
+                                                               void* userdata) {
+    if (handle == nullptr || callback == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->set_callback_on_connected([=]() { callback(handle, userdata); });
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}
+
+simpleble_err_t simpleble_peripheral_set_callback_on_disconnected(simpleble_peripheral_t handle,
+                                                                  void (*callback)(simpleble_peripheral_t, void*),
+                                                                  void* userdata) {
+    if (handle == nullptr || callback == nullptr) {
+        return SIMPLEBLE_FAILURE;
+    }
+
+    SimpleBLE::Safe::Peripheral* peripheral = (SimpleBLE::Safe::Peripheral*)handle;
+
+    bool success = peripheral->set_callback_on_disconnected([=]() { callback(handle, userdata); });
+
+    return success ? SIMPLEBLE_SUCCESS : SIMPLEBLE_FAILURE;
+}

data/vendor/simpleble/simplecble/src/simpleble.cpp

@@ -0,0 +1,5 @@
+#include <simpleble_c/simpleble.h>
+
+#include <cstdlib>
+
+void simpleble_free(void* handle) { free(handle); }

data/vendor/simpleble/simplecble/src/utils.cpp

@@ -0,0 +1,15 @@
+#include <simpleble_c/utils.h>
+
+#include <simpleble_c/types.h>
+
+simpleble_os_t simpleble_get_operating_system() {
+#ifdef _WIN32
+    return SIMPLEBLE_OS_WINDOWS;
+#elif __APPLE__
+    return SIMPLEBLE_OS_MACOS;
+#elif __linux__
+    return SIMPLEBLE_OS_LINUX;
+#endif
+}
+
+const char* simpleble_get_version() { return SIMPLEBLE_VERSION; }