simpleble 0.0.1

data/vendor/simpleble/simpleble/src/frontends/safe/PeripheralSafe.cpp

@@ -0,0 +1,219 @@
+#include <simpleble/Exceptions.h>
+#include <simpleble/PeripheralSafe.h>
+
+using namespace SimpleBLE::Safe;
+
+using SPeripheral = SimpleBLE::Safe::Peripheral;
+using UPeripheral = SimpleBLE::Peripheral;
+
+SPeripheral::Peripheral(UPeripheral& peripheral) : internal_(peripheral) {}
+SPeripheral::Peripheral(UPeripheral&& peripheral) : internal_(std::move(peripheral)) {}
+
+std::optional<std::string> SPeripheral::identifier() noexcept {
+    try {
+        return internal_.identifier();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<SimpleBLE::BluetoothAddress> SPeripheral::address() noexcept {
+    try {
+        return internal_.address();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<SimpleBLE::BluetoothAddressType> SPeripheral::address_type() noexcept {
+    try {
+        return internal_.address_type();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<int16_t> SPeripheral::rssi() noexcept {
+    try {
+        return internal_.rssi();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<int16_t> SPeripheral::tx_power() noexcept {
+    try {
+        return internal_.tx_power();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+std::optional<uint16_t> SPeripheral::mtu() noexcept {
+    try {
+        return internal_.mtu();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::connect() noexcept {
+    try {
+        internal_.connect();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::disconnect() noexcept {
+    try {
+        internal_.disconnect();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::optional<bool> SPeripheral::is_connected() noexcept {
+    try {
+        return internal_.is_connected();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<bool> SPeripheral::is_connectable() noexcept {
+    try {
+        return internal_.is_connectable();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<bool> SPeripheral::is_paired() noexcept {
+    try {
+        return internal_.is_paired();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::unpair() noexcept {
+    try {
+        internal_.unpair();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::optional<std::map<uint16_t, SimpleBLE::ByteArray>> SPeripheral::manufacturer_data() noexcept {
+    try {
+        return internal_.manufacturer_data();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<std::vector<SimpleBLE::Service>> SPeripheral::services() noexcept {
+    try {
+        return internal_.services();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<SimpleBLE::ByteArray> SPeripheral::read(BluetoothUUID const& service,
+                                                      BluetoothUUID const& characteristic) noexcept {
+    try {
+        return internal_.read(service, characteristic);
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                ByteArray const& data) noexcept {
+    try {
+        internal_.write_request(service, characteristic, data);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                ByteArray const& data) noexcept {
+    try {
+        internal_.write_command(service, characteristic, data);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::notify(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                         std::function<void(ByteArray payload)> callback) noexcept {
+    try {
+        internal_.notify(service, characteristic, std::move(callback));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                           std::function<void(ByteArray payload)> callback) noexcept {
+    try {
+        internal_.indicate(service, characteristic, std::move(callback));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) noexcept {
+    try {
+        internal_.unsubscribe(service, characteristic);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::optional<SimpleBLE::ByteArray> SPeripheral::read(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                                      BluetoothUUID const& descriptor) noexcept {
+    try {
+        return internal_.read(service, characteristic, descriptor);
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::write(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                        BluetoothUUID const& descriptor, ByteArray const& data) noexcept {
+    try {
+        internal_.write(service, characteristic, descriptor, data);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::set_callback_on_connected(std::function<void()> on_connected) noexcept {
+    try {
+        internal_.set_callback_on_connected(std::move(on_connected));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::set_callback_on_disconnected(std::function<void()> on_disconnected) noexcept {
+    try {
+        internal_.set_callback_on_disconnected(std::move(on_disconnected));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}

data/vendor/simpleble/simpleble/src_c/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/simpleble/src_c/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.
+            }
+        });
+}